superGate.c File Reference

#include <math.h>
#include "superInt.h"

Include dependency graph for superGate.c:

Go to the source code of this file.

Classes
struct	Super_ManStruct_t_
struct	Super_GateStruct_t_

Macros
#define	SUPER_MASK(n)
	DECLARATIONS ///.
#define	SUPER_FULL   (~((unsigned)0))
#define	SUPER_NO_VAR   (-9999.0)
#define	SUPER_EPSILON   (0.001)
#define	Super_ManForEachGate(GateArray, Limit, Index, Gate)

Typedefs
typedef struct Super_ManStruct_t_	Super_Man_t
typedef struct Super_GateStruct_t_	Super_Gate_t

Functions
void	Super_Precompute (Mio_Library_t *pLibGen, int nVarsMax, int nLevels, int nGatesMax, float tDelayMax, float tAreaMax, int TimeLimit, int fSkipInv, int fVerbose, char *pFileName)
	FUNCTION DEFINITIONS ///.
Vec_Str_t *	Super_PrecomputeStr (Mio_Library_t *pLibGen, int nVarsMax, int nLevels, int nGatesMax, float tDelayMax, float tAreaMax, int TimeLimit, int fSkipInv, int fVerbose)
void	Super_WriteFileHeaderStr (Super_Man_t *pMan, Vec_Str_t *vStr)
void	Super_WriteLibraryGateName_rec (Super_Gate_t *pGate, char *pBuffer)
char *	Super_WriteLibraryGateName (Super_Gate_t *pGate)
void	Super_WriteLibraryGate (FILE *pFile, Super_Man_t *pMan, Super_Gate_t *pGate, int Num)
void	Super_WriteLibraryTreeFile_rec (FILE *pFile, Super_Man_t *pMan, Super_Gate_t *pSuper, int *pCounter)
void	Super_WriteLibraryTreeStr_rec (Vec_Str_t *vStr, Super_Man_t *pMan, Super_Gate_t *pSuper, int *pCounter)
void	Super_WriteLibraryTree (Super_Man_t *pMan)

Macro Definition Documentation

SUPER_EPSILON

#define SUPER_EPSILON   (0.001)

Definition at line 33 of file superGate.c.

SUPER_FULL

#define SUPER_FULL   (~((unsigned)0))

Definition at line 31 of file superGate.c.

Super_ManForEachGate

#define Super_ManForEachGate	(		GateArray,
			Limit,
			Index,
			Gate )

Value:

    for ( Index = 0;                                             \
          Index < Limit && (Gate = GateArray[Index]);            \
          Index++ )

Definition at line 97 of file superGate.c.

#define Super_ManForEachGate( GateArray, Limit, Index, Gate )    \
    for ( Index = 0;                                             \
          Index < Limit && (Gate = GateArray[Index]);            \
          Index++ )

SUPER_MASK

#define SUPER_MASK

(

n

)

Value:

((~((unsigned)0)) >> (32-(n)))

DECLARATIONS ///.

CFile****************************************************************

FileName [superGate.c]

PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]

Synopsis [Pre-computation of supergates.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 8, 2003.]

Revision [

Id

superGate.c,v 1.7 2004/08/03 00:11:40 satrajit Exp

]

Definition at line 30 of file superGate.c.

SUPER_NO_VAR

#define SUPER_NO_VAR   (-9999.0)

Definition at line 32 of file superGate.c.

Typedef Documentation

Super_Gate_t

typedef struct Super_GateStruct_t_ Super_Gate_t

Definition at line 37 of file superGate.c.

Super_Man_t

typedef struct Super_ManStruct_t_ Super_Man_t

Definition at line 36 of file superGate.c.

Function Documentation

Super_Precompute()

void Super_Precompute	(	Mio_Library_t *	pLibGen,
		int	nVarsMax,
		int	nLevels,
		int	nGatesMax,
		float	tDelayMax,
		float	tAreaMax,
		int	TimeLimit,
		int	fSkipInv,
		int	fVerbose,
		char *	pFileName )

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Precomputes the library of supergates.]

Description []

SideEffects []

SeeAlso []

Definition at line 140 of file superGate.c.

{
    Vec_Str_t * vStr;
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
    {     
        printf( "Cannot open output file \"%s\".\n", pFileName );
        return;
    }
    vStr = Super_PrecomputeStr( pLibGen, nVarsMax, nLevels, nGatesMax, tDelayMax, tAreaMax, TimeLimit, fSkipInv, fVerbose );
    if ( vStr ) 
    {
        fwrite( Vec_StrArray(vStr), 1, Vec_StrSize(vStr), pFile );
        Vec_StrFree( vStr );
    }
    fclose( pFile );
    // report the result of writing
    if ( fVerbose )
    {
        printf( "The supergates are written using new format \"%s\" ", pFileName );
        printf( "(%0.3f MB).\n", ((double)Extra_FileSize(pFileName))/(1<<20) );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Super_PrecomputeStr()

Vec_Str_t * Super_PrecomputeStr	(	Mio_Library_t *	pLibGen,
		int	nVarsMax,
		int	nLevels,
		int	nGatesMax,
		float	tDelayMax,
		float	tAreaMax,
		int	TimeLimit,
		int	fSkipInv,
		int	fVerbose )

Function*************************************************************

Synopsis [Precomputes the library of supergates.]

Description []

SideEffects []

SeeAlso []

Definition at line 175 of file superGate.c.

{
    Vec_Str_t * vStr;
    Super_Man_t * pMan;
    Mio_Gate_t ** ppGates;
    int nGates, Level;
    abctime clk, clockStart;
 
    assert( nVarsMax < 7 );
    if ( nGatesMax && nGatesMax < nVarsMax )
    {
        fprintf( stderr, "Erro! The number of supergates requested (%d) in less than the number of variables (%d).\n", nGatesMax, nVarsMax );
        fprintf( stderr, "The library cannot be computed.\n" );
        return NULL;
    }
 
    // get the root gates
    ppGates = Mio_CollectRoots( pLibGen, nVarsMax, tDelayMax, 0, &nGates, fVerbose );
    if ( nGatesMax && nGates >= nGatesMax )
    {
        fprintf( stdout, "Warning! Genlib library contains more gates than can be computed.\n");
        fprintf( stdout, "Only one-gate supergates are included in the supergate library.\n" );
    }
 
    // start the manager
    pMan = Super_ManStart();
    pMan->pName     = Mio_LibraryReadName(pLibGen);
    pMan->nGatesMax = nGatesMax;
    pMan->fSkipInv  = fSkipInv;
    pMan->tDelayMax = tDelayMax;
    pMan->tAreaMax  = tAreaMax;
    pMan->TimeLimit = TimeLimit; // in seconds
    pMan->TimeStop  = TimeLimit ? TimeLimit * CLOCKS_PER_SEC + Abc_Clock() : 0; // in CPU ticks
    pMan->fVerbose  = fVerbose;
 
    if ( nGates == 0 )
    {
        fprintf( stderr, "Error: No genlib gates satisfy the limits criteria. Stop.\n");
        fprintf( stderr, "Limits: max delay =  %.2f, max area =  %.2f, time limit = %d sec.\n", 
            pMan->tDelayMax, pMan->tAreaMax, pMan->TimeLimit );
 
        // stop the manager
        Super_ManStop( pMan );
        ABC_FREE( ppGates );
 
        return NULL;
    }
 
    // get the starting supergates
    Super_First( pMan, nVarsMax );
 
    // perform the computation of supergates
    clockStart = Abc_Clock();
if ( fVerbose )
{
    printf( "Computing supergates with %d inputs, %d levels, and %d max gates.\n", 
        pMan->nVarsMax, nLevels, nGatesMax );
    printf( "Limits: max delay =  %.2f, max area =  %.2f, time limit = %d sec.\n", 
        pMan->tDelayMax, pMan->tAreaMax, pMan->TimeLimit );
}
 
    for ( Level = 1; Level <= nLevels; Level++ )
    {
        if ( pMan->TimeStop && Abc_Clock() > pMan->TimeStop )
            break;
clk = Abc_Clock();
        Super_Compute( pMan, ppGates, nGates, nGatesMax, fSkipInv );
        pMan->nLevels = Level;
if ( fVerbose )
{
        printf( "Lev %d: Try =%12d. Add =%6d. Rem =%5d. Save =%6d. Lookups =%12d. Aliases =%12d. ",
           Level, pMan->nTried, pMan->nAdded, pMan->nRemoved, pMan->nAdded - pMan->nRemoved, pMan->nLookups, pMan->nAliases );
ABC_PRT( "Time", Abc_Clock() - clk );
fflush( stdout );
}
    }
    pMan->Time = Abc_Clock() - clockStart;
 
if ( fVerbose )
{
printf( "Writing the output file...\n" );
fflush( stdout );
}
    // write them into a file
    vStr = Super_Write( pMan );
 
    // stop the manager
    Super_ManStop( pMan );
    ABC_FREE( ppGates );
    return vStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Super_WriteFileHeaderStr()

void Super_WriteFileHeaderStr	(	Super_Man_t *	pMan,
		Vec_Str_t *	vStr )

Definition at line 1092 of file superGate.c.

{
    char pBuffer[1000];
    sprintf( pBuffer, "#\n" );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# Supergate library derived for \"%s\" on %s.\n", pMan->pName, Extra_TimeStamp() );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "#\n" );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# Command line: \"super -I %d -L %d -N %d -T %d -D %.2f -A %.2f %s %s\".\n", 
        pMan->nVarsMax, pMan->nLevels, pMan->nGatesMax, pMan->TimeLimit, pMan->tDelayMax, pMan->tAreaMax, (pMan->fSkipInv? "" : "-s"), pMan->pName );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "#\n" );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The number of inputs      = %10d.\n", pMan->nVarsMax );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The number of levels      = %10d.\n", pMan->nLevels );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The maximum delay         = %10.2f.\n", pMan->tDelayMax  );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The maximum area          = %10.2f.\n", pMan->tAreaMax );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The maximum runtime (sec) = %10d.\n", pMan->TimeLimit );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "#\n" );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The number of attempts    = %10d.\n", pMan->nTried  );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The number of supergates  = %10d.\n", pMan->nGates  );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The number of functions   = %10d.\n", pMan->nUnique );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# The total functions       = %.0f (2^%d).\n", pow((double)2,pMan->nMints), pMan->nMints );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "#\n" );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "# Generation time           = %10.2f sec.\n", (float)(pMan->Time)/(float)(CLOCKS_PER_SEC) );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "#\n" );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "%s\n", pMan->pName );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "%d\n", pMan->nVarsMax );
    Vec_StrPrintStr( vStr, pBuffer );
    sprintf( pBuffer, "%d\n", pMan->nGates );
    Vec_StrPrintStr( vStr, pBuffer );
}

Here is the call graph for this function:

Super_WriteLibraryGate()

void Super_WriteLibraryGate	(	FILE *	pFile,
		Super_Man_t *	pMan,
		Super_Gate_t *	pGate,
		int	Num )

Definition at line 1226 of file superGate.c.

{
    int i;
    fprintf( pFile, "%04d  ", Num );                         // the number
    Extra_PrintBinary( pFile, pGate->uTruth, pMan->nMints ); // the truth table
    fprintf( pFile, "   %5.2f", pGate->tDelayMax );          // the max delay
    fprintf( pFile, "  " );                                  
    for ( i = 0; i < pMan->nVarsMax; i++ )                   // the pin-to-pin delays
        fprintf( pFile, " %5.2f", pGate->ptDelays[i]==SUPER_NO_VAR? 0.0 : pGate->ptDelays[i] );  
    fprintf( pFile, "   %5.2f", pGate->Area );               // the area
    fprintf( pFile, "   " );
    fprintf( pFile, "%s", Super_WriteLibraryGateName(pGate) );      // the symbolic expression
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Super_WriteLibraryGateName()

char * Super_WriteLibraryGateName

(

Super_Gate_t *

pGate

)

Definition at line 1219 of file superGate.c.

{
    static char Buffer[2000];
    Buffer[0] = 0;
    Super_WriteLibraryGateName_rec( pGate, Buffer );
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Super_WriteLibraryGateName_rec()

void Super_WriteLibraryGateName_rec	(	Super_Gate_t *	pGate,
		char *	pBuffer )

Function*************************************************************

Synopsis [Writes the gates into the file.]

Description []

SideEffects []

SeeAlso []

Definition at line 1198 of file superGate.c.

{
    char Buffer[10];
    int i;
 
    if ( pGate->pRoot == NULL )
    {
        sprintf( Buffer, "%c", 'a' + pGate->Number );
        strcat( pBuffer, Buffer );
        return;
    }
    strcat( pBuffer, Mio_GateReadName(pGate->pRoot) );
    strcat( pBuffer, "(" );
    for ( i = 0; i < (int)pGate->nFanins; i++ )
    {
        if ( i )
            strcat( pBuffer, "," );
        Super_WriteLibraryGateName_rec( pGate->pFanins[i], pBuffer );
    }
    strcat( pBuffer, ")" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Super_WriteLibraryTree()

void Super_WriteLibraryTree

(

Super_Man_t *

pMan

)

Definition at line 1449 of file superGate.c.

{
    Vec_Str_t * vStr;
    char * pFileName = Extra_FileNameGenericAppend( pMan->pName, ".super" );
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
    {     
        printf( "Cannot open output file \"%s\".\n", pFileName );
        return;
    }
    vStr = Super_WriteLibraryTreeStr( pMan );
    fwrite( Vec_StrArray(vStr), 1, Vec_StrSize(vStr), pFile );
    fclose( pFile );
    Vec_StrFree( vStr );
    // report the result of writing
    if ( pMan->fVerbose )
    {
        printf( "The supergates are written using new format \"%s\" ", pFileName );
        printf( "(%0.3f MB).\n", ((double)Extra_FileSize(pFileName))/(1<<20) );
    }
}

Here is the call graph for this function:

Super_WriteLibraryTreeFile_rec()

void Super_WriteLibraryTreeFile_rec	(	FILE *	pFile,
		Super_Man_t *	pMan,
		Super_Gate_t *	pSuper,
		int *	pCounter )

Function*************************************************************

Synopsis [Recursively writes the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 1309 of file superGate.c.

{
    int nFanins, i;
    // skip an elementary variable and a gate that was already written
    if ( pSuper->fVar || pSuper->Number > 0 )
        return;
    // write the fanins
    nFanins = Mio_GateReadPinNum(pSuper->pRoot);
    for ( i = 0; i < nFanins; i++ )
        Super_WriteLibraryTreeFile_rec( pFile, pMan, pSuper->pFanins[i], pCounter );
    // finally write the gate
    pSuper->Number = (*pCounter)++;
    fprintf( pFile, "%s", pSuper->fSuper? "* " : "" );
    fprintf( pFile, "%s", Mio_GateReadName(pSuper->pRoot) );
    for ( i = 0; i < nFanins; i++ )
        fprintf( pFile, " %d", pSuper->pFanins[i]->Number );
    // write the formula 
    // this step is optional, the resulting library will work in any case
    // however, it may be helpful to for debugging to compare the same library 
    // written in the old format and written in the new format with formulas
//    fprintf( pFile, "    # %s", Super_WriteLibraryGateName( pSuper ) );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Super_WriteLibraryTreeStr_rec()

void Super_WriteLibraryTreeStr_rec	(	Vec_Str_t *	vStr,
		Super_Man_t *	pMan,
		Super_Gate_t *	pSuper,
		int *	pCounter )

Function*************************************************************

Synopsis [Recursively writes the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 1389 of file superGate.c.

{
    int nFanins, i;
    // skip an elementary variable and a gate that was already written
    if ( pSuper->fVar || pSuper->Number > 0 )
        return;
    // write the fanins
    nFanins = Mio_GateReadPinNum(pSuper->pRoot);
    for ( i = 0; i < nFanins; i++ )
        Super_WriteLibraryTreeStr_rec( vStr, pMan, pSuper->pFanins[i], pCounter );
    // finally write the gate
    pSuper->Number = (*pCounter)++;
//    fprintf( pFile, "%s", pSuper->fSuper? "* " : "" );
//    fprintf( pFile, "%s", Mio_GateReadName(pSuper->pRoot) );
//    for ( i = 0; i < nFanins; i++ )
//        fprintf( pFile, " %d", pSuper->pFanins[i]->Number );
    Vec_StrPrintStr( vStr, pSuper->fSuper? "* " : "" );
    Vec_StrPrintStr( vStr, Mio_GateReadName(pSuper->pRoot) );
    for ( i = 0; i < nFanins; i++ )
    {
        Vec_StrPrintStr( vStr, " " );
        Vec_StrPrintNum( vStr, pSuper->pFanins[i]->Number );    
    }
    // write the formula 
    // this step is optional, the resulting library will work in any case
    // however, it may be helpful to for debugging to compare the same library 
    // written in the old format and written in the new format with formulas
//    fprintf( pFile, "    # %s", Super_WriteLibraryGateName( pSuper ) );
//    fprintf( pFile, "\n" );
    Vec_StrPrintStr( vStr, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function: