mio.h File Reference

Go to the source code of this file.

Classes
struct	Mio_Cell_t_
struct	Mio_Cell2_t_

Macros
#define	Mio_LibraryForEachGate(Lib, Gate)
	GLOBAL VARIABLES ///.
#define	Mio_LibraryForEachGateSafe(Lib, Gate, Gate2)
#define	Mio_GateForEachPin(Gate, Pin)
#define	Mio_GateForEachPinSafe(Gate, Pin, Pin2)

Typedefs
typedef struct Mio_LibraryStruct_t_	Mio_Library_t
typedef struct Mio_GateStruct_t_	Mio_Gate_t
typedef struct Mio_PinStruct_t_	Mio_Pin_t
typedef struct Mio_Cell_t_	Mio_Cell_t
typedef struct Mio_Cell2_t_	Mio_Cell2_t

Enumerations
enum	Mio_PinPhase_t { MIO_PHASE_UNKNOWN , MIO_PHASE_INV , MIO_PHASE_NONINV }
	INCLUDES ///. More...

Functions
void	Mio_UpdateGenlib (Mio_Library_t *pLib)
	FUNCTION DEFINITIONS ///.
int	Mio_UpdateGenlib2 (Vec_Str_t *vStr, Vec_Str_t *vStr2, char *pFileName, int fVerbose)
char *	Mio_LibraryReadName (Mio_Library_t *pLib)
	DECLARATIONS ///.
char *	Mio_LibraryReadFileName (Mio_Library_t *pLib)
int	Mio_LibraryReadGateNum (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadGates (Mio_Library_t *pLib)
Mio_Gate_t **	Mio_LibraryReadGateArray (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadGateById (Mio_Library_t *pLib, int iD)
Mio_Gate_t *	Mio_LibraryReadGateByName (Mio_Library_t *pLib, char *pName, char *pOutName)
char *	Mio_LibraryReadSopByName (Mio_Library_t *pLib, char *pName)
Mio_Gate_t *	Mio_LibraryReadGateByTruth (Mio_Library_t *pLib, word t)
Mio_Gate_t *	Mio_LibraryReadConst0 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadConst1 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadNand2 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadAnd2 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadNor2 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadOr2 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadBuf (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadInv (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayInvRise (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayInvFall (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayInvMax (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayNand2Rise (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayNand2Fall (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayNand2Max (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayAnd2Max (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayAigNode (Mio_Library_t *pLib)
float	Mio_LibraryReadAreaInv (Mio_Library_t *pLib)
float	Mio_LibraryReadAreaBuf (Mio_Library_t *pLib)
float	Mio_LibraryReadAreaNand2 (Mio_Library_t *pLib)
int	Mio_LibraryReadGateNameMax (Mio_Library_t *pLib)
void	Mio_LibrarySetName (Mio_Library_t *pLib, char *pName)
char *	Mio_GateReadName (Mio_Gate_t *pGate)
char *	Mio_GateReadOutName (Mio_Gate_t *pGate)
double	Mio_GateReadArea (Mio_Gate_t *pGate)
char *	Mio_GateReadForm (Mio_Gate_t *pGate)
Mio_Pin_t *	Mio_GateReadPins (Mio_Gate_t *pGate)
Mio_Library_t *	Mio_GateReadLib (Mio_Gate_t *pGate)
Mio_Gate_t *	Mio_GateReadNext (Mio_Gate_t *pGate)
Mio_Gate_t *	Mio_GateReadTwin (Mio_Gate_t *pGate)
int	Mio_GateReadPinNum (Mio_Gate_t *pGate)
double	Mio_GateReadDelayMax (Mio_Gate_t *pGate)
char *	Mio_GateReadSop (Mio_Gate_t *pGate)
Vec_Int_t *	Mio_GateReadExpr (Mio_Gate_t *pGate)
word	Mio_GateReadTruth (Mio_Gate_t *pGate)
word *	Mio_GateReadTruthP (Mio_Gate_t *pGate)
int	Mio_GateReadValue (Mio_Gate_t *pGate)
int	Mio_GateReadCell (Mio_Gate_t *pGate)
int	Mio_GateReadProfile (Mio_Gate_t *pGate)
int	Mio_GateReadProfile2 (Mio_Gate_t *pGate)
char *	Mio_GateReadPinName (Mio_Gate_t *pGate, int iPin)
float	Mio_GateReadPinDelay (Mio_Gate_t *pGate, int iPin)
void	Mio_GateSetValue (Mio_Gate_t *pGate, int Value)
void	Mio_GateSetCell (Mio_Gate_t *pGate, int Cell)
void	Mio_GateSetProfile (Mio_Gate_t *pGate, int Prof)
void	Mio_GateSetProfile2 (Mio_Gate_t *pGate, int Prof)
void	Mio_GateIncProfile2 (Mio_Gate_t *pGate)
void	Mio_GateDecProfile2 (Mio_Gate_t *pGate)
void	Mio_GateAddToProfile (Mio_Gate_t *pGate, int Prof)
void	Mio_GateAddToProfile2 (Mio_Gate_t *pGate, int Prof)
int	Mio_GateIsInv (Mio_Gate_t *pGate)
char *	Mio_PinReadName (Mio_Pin_t *pPin)
Mio_PinPhase_t	Mio_PinReadPhase (Mio_Pin_t *pPin)
double	Mio_PinReadInputLoad (Mio_Pin_t *pPin)
double	Mio_PinReadMaxLoad (Mio_Pin_t *pPin)
double	Mio_PinReadDelayBlockRise (Mio_Pin_t *pPin)
double	Mio_PinReadDelayFanoutRise (Mio_Pin_t *pPin)
double	Mio_PinReadDelayBlockFall (Mio_Pin_t *pPin)
double	Mio_PinReadDelayFanoutFall (Mio_Pin_t *pPin)
double	Mio_PinReadDelayBlockMax (Mio_Pin_t *pPin)
Mio_Pin_t *	Mio_PinReadNext (Mio_Pin_t *pPin)
char *	Mio_ReadFile (char *FileName, int fAddEnd)
Mio_Library_t *	Mio_LibraryRead (char *FileName, char *pBuffer, char *ExcludeFile, int nFaninLimit, int fVerbose)
int	Mio_LibraryReadExclude (char *ExcludeFile, st__table *tExcludeGate)
int	Mio_LibraryParseFormulas (Mio_Library_t *pLib)
	FUNCTION DEFINITIONS ///.
Vec_Int_t *	Mio_ParseFormula (char *pFormInit, char **ppVarNames, int nVars)
Vec_Wrd_t *	Mio_ParseFormulaTruth (char *pFormInit, char **ppVarNames, int nVars)
int	Mio_ParseCheckFormula (Mio_Gate_t *pGate, char *pForm)
char *	Mio_LibDeriveSop (int nVars, Vec_Int_t *vExpr, Vec_Str_t *vStr)
void	Mio_LibraryDelete (Mio_Library_t *pLib)
	DECLARATIONS ///.
void	Mio_GateDelete (Mio_Gate_t *pGate)
void	Mio_PinDelete (Mio_Pin_t *pPin)
Mio_Pin_t *	Mio_PinDup (Mio_Pin_t *pPin)
void	Mio_WriteLibrary (FILE *pFile, Mio_Library_t *pLib, int fPrintSops, int fShort, int fSelected)
void	Mio_WriteLibraryVerilog (FILE *pFile, Mio_Library_t *pLib, int fPrintSops, int fShort, int fSelected)
Mio_Gate_t **	Mio_CollectRoots (Mio_Library_t *pLib, int nInputs, float tDelay, int fSkipInv, int *pnGates, int fVerbose)
Mio_Cell_t *	Mio_CollectRootsNew (Mio_Library_t *pLib, int nInputs, int *pnGates, int fVerbose)
Mio_Cell_t *	Mio_CollectRootsNewDefault (int nInputs, int *pnGates, int fVerbose)
Mio_Cell2_t *	Mio_CollectRootsNewDefault2 (int nInputs, int *pnGates, int fVerbose)
int	Mio_CollectRootsNewDefault3 (int nInputs, Vec_Ptr_t **pvNames, Vec_Wrd_t **pvTruths)
word	Mio_DeriveTruthTable6 (Mio_Gate_t *pGate)
void	Mio_DeriveTruthTable (Mio_Gate_t *pGate, unsigned uTruthsIn[][2], int nSigns, int nInputs, unsigned uTruthRes[])
void	Mio_DeriveGateDelays (Mio_Gate_t *pGate, float **ptPinDelays, int nPins, int nInputs, float tDelayZero, float *ptDelaysRes, float *ptPinDelayMax)
Mio_Gate_t *	Mio_GateCreatePseudo (int nInputs)
void	Mio_LibraryShiftDelay (Mio_Library_t *pLib, double Shift)
void	Mio_LibraryMultiArea (Mio_Library_t *pLib, double Multi)
void	Mio_LibraryMultiDelay (Mio_Library_t *pLib, double Multi)
void	Mio_LibraryTransferDelays (Mio_Library_t *pLibD, Mio_Library_t *pLibS)
void	Mio_LibraryTransferCellIds ()
void	Mio_LibraryReadProfile (FILE *pFile, Mio_Library_t *pLib)
void	Mio_LibraryWriteProfile (FILE *pFile, Mio_Library_t *pLib)
void	Mio_LibraryTransferProfile (Mio_Library_t *pLibDst, Mio_Library_t *pLibSrc)
void	Mio_LibraryTransferProfile2 (Mio_Library_t *pLibDst, Mio_Library_t *pLibSrc)
int	Mio_LibraryHasProfile (Mio_Library_t *pLib)
void	Mio_LibraryCleanProfile2 (Mio_Library_t *pLib)
void	Mio_LibraryShortNames (Mio_Library_t *pLib)
void	Mio_LibraryMatchesStop (Mio_Library_t *pLib)
void	Mio_LibraryMatchesStart (Mio_Library_t *pLib, int fPinFilter, int fPinPerm, int fPinQuick)
void	Mio_LibraryMatchesFetch (Mio_Library_t *pLib, Vec_Mem_t **pvTtMem, Vec_Wec_t **pvTt2Match, Mio_Cell2_t **ppCells, int *pnCells, int fPinFilter, int fPinPerm, int fPinQuick)
void	Mio_LibraryMatches2Stop (Mio_Library_t *pLib)
void	Mio_LibraryMatches2Start (Mio_Library_t *pLib)
void	Mio_LibraryMatches2Fetch (Mio_Library_t *pLib, Vec_Ptr_t **pvNames, Vec_Wrd_t **pvTruths, Vec_Int_t **pvTt2Match4, Vec_Int_t **pvConfigs, Vec_Mem_t *pvTtMem2[3], Vec_Int_t *pvTt2Match2[3])
Mio_Library_t *	Abc_SclDeriveGenlibSimple (void *pScl)
Mio_Library_t *	Abc_SclDeriveGenlib (void *pScl, void *pMio, float Slew, float Gain, int nGatesMin, int fVerbose)

Macro Definition Documentation

Mio_GateForEachPin

#define Mio_GateForEachPin	(		Gate,
			Pin )

Value:

    for ( Pin = Mio_GateReadPins(Gate);                       \
          Pin;                                                \
          Pin = Mio_PinReadNext(Pin) )

Definition at line 92 of file mio.h.

#define Mio_GateForEachPin( Gate, Pin )                       \
    for ( Pin = Mio_GateReadPins(Gate);                       \
          Pin;                                                \
          Pin = Mio_PinReadNext(Pin) )

Mio_GateForEachPinSafe

#define Mio_GateForEachPinSafe	(		Gate,
			Pin,
			Pin2 )

Value:

    for ( Pin = Mio_GateReadPins(Gate),                       \
          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL);           \
          Pin;                                                \
          Pin = Pin2,                                         \
          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL) )

Definition at line 96 of file mio.h.

#define Mio_GateForEachPinSafe( Gate, Pin, Pin2 )             \
    for ( Pin = Mio_GateReadPins(Gate),                       \
          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL);           \
          Pin;                                                \
          Pin = Pin2,                                         \
          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL) )

Mio_LibraryForEachGate

#define Mio_LibraryForEachGate	(		Lib,
			Gate )

Value:

    for ( Gate = Mio_LibraryReadGates(Lib);                   \
          Gate;                                               \
          Gate = Mio_GateReadNext(Gate) )

GLOBAL VARIABLES ///.

MACRO DEFINITIONS ///

Definition at line 81 of file mio.h.

#define Mio_LibraryForEachGate( Lib, Gate )                   \
    for ( Gate = Mio_LibraryReadGates(Lib);                   \
          Gate;                                               \
          Gate = Mio_GateReadNext(Gate) )

Mio_LibraryForEachGateSafe

#define Mio_LibraryForEachGateSafe	(		Lib,
			Gate,
			Gate2 )

Value:

    for ( Gate = Mio_LibraryReadGates(Lib),                   \
          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL);       \
          Gate;                                               \
          Gate = Gate2,                                       \
          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL) )

Definition at line 85 of file mio.h.

#define Mio_LibraryForEachGateSafe( Lib, Gate, Gate2 )        \
    for ( Gate = Mio_LibraryReadGates(Lib),                   \
          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL);       \
          Gate;                                               \
          Gate = Gate2,                                       \
          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL) )

Typedef Documentation

Mio_Cell2_t

typedef struct Mio_Cell2_t_ Mio_Cell2_t

Definition at line 57 of file mio.h.

Mio_Cell_t

typedef struct Mio_Cell_t_ Mio_Cell_t

Definition at line 46 of file mio.h.

Mio_Gate_t

typedef struct Mio_GateStruct_t_ Mio_Gate_t

Definition at line 43 of file mio.h.

Mio_Library_t

typedef struct Mio_LibraryStruct_t_ Mio_Library_t

Definition at line 42 of file mio.h.

Mio_Pin_t

typedef struct Mio_PinStruct_t_ Mio_Pin_t

Definition at line 44 of file mio.h.

Enumeration Type Documentation

Mio_PinPhase_t

enum Mio_PinPhase_t

INCLUDES ///.

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

FileName [mio.h]

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

Synopsis [File reading/writing for technology mapping.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

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

Revision [

Id

mio.h,v 1.6 2004/08/09 22:16:31 satrajit Exp

] PARAMETERS /// STRUCTURE DEFINITIONS ///

Enumerator
MIO_PHASE_UNKNOWN
MIO_PHASE_INV
MIO_PHASE_NONINV

Definition at line 40 of file mio.h.

{ MIO_PHASE_UNKNOWN, MIO_PHASE_INV, MIO_PHASE_NONINV } Mio_PinPhase_t;

Function Documentation

Abc_SclDeriveGenlib()

Mio_Library_t * Abc_SclDeriveGenlib ( void * pScl, void * pMio, float Slew, float Gain, int nGatesMin, int fVerbose )

extern

Definition at line 1078 of file sclLibUtil.c.

{
    int nCellCount = 0;
    SC_Lib * p = (SC_Lib *)pScl;
    float Slew = (SlewInit == 0) ? Abc_SclComputeAverageSlew(p) : SlewInit;
    Vec_Str_t * vStr;
    Mio_Library_t * pLib;
    if ( pMio == NULL )
        vStr = Abc_SclProduceGenlibStr( p, Slew, Gain, nGatesMin, 0, &nCellCount );
    else
        vStr = Abc_SclProduceGenlibStrProfile( p, (Mio_Library_t *)pMio, Slew, Gain, nGatesMin, &nCellCount );
    pLib = Mio_LibraryRead( p->pFileName, Vec_StrArray(vStr), NULL, 0, 0 );  
    Vec_StrFree( vStr );
    if ( !pLib )
        printf( "Reading library has filed.\n" );
    else if ( fVerbose )
        printf( "Derived GENLIB library \"%s\" with %d gates using slew %.2f ps and gain %.2f.\n", p->pName, nCellCount, Slew, Gain );
    return pLib;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclDeriveGenlibSimple()

Mio_Library_t * Abc_SclDeriveGenlibSimple ( void * pScl )

extern

Definition at line 845 of file sclLibUtil.c.

{
    SC_Lib * p = (SC_Lib *)pScl;
    Vec_Str_t * vStr = Abc_SclProduceGenlibStrSimple( p );
    Mio_Library_t * pLib = Mio_LibraryRead( p->pFileName, Vec_StrArray(vStr), NULL, 0, 0 );  
    Vec_StrFree( vStr );
    if ( pLib )
        printf( "Derived GENLIB library \"%s\" with %d gates.\n", p->pName, SC_LibCellNum(p) );
    else
        printf( "Reading library has filed.\n" );
    return pLib;
}

Here is the call graph for this function:

Mio_CollectRoots()

Mio_Gate_t ** Mio_CollectRoots ( Mio_Library_t * pLib, int nInputs, float tDelay, int fSkipInv, int * pnGates, int fVerbose )

extern

Definition at line 515 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Gate_t ** ppGates;
    int i, nGates, iGate, fProfile;
    nGates = Mio_LibraryReadGateNum( pLib );
    ppGates = ABC_ALLOC( Mio_Gate_t *, nGates );
    iGate = 0;
    // check if profile is entered
    fProfile = Mio_LibraryHasProfile( pLib );
    if ( fProfile )
        printf( "Mio_CollectRoots(): Using gate profile to select gates for mapping.\n" );
    // for each functionality, select gate with the smallest area
    // if equal areas, select gate with lexicographically smaller name
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs > nInputs )
            continue;
        if ( fProfile && Mio_GateReadProfile(pGate) == 0 && pGate->nInputs > 1 )
            continue;
        if ( tDelay > 0.0 && pGate->dDelayMax > (double)tDelay )
            continue;
        if ( pGate->uTruth == 0 || pGate->uTruth == ~(word)0 )
            continue;
        if ( pGate->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) )
            continue;
        if ( pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) && fSkipInv )
            continue;
        if ( pGate->pTwin ) // skip multi-output gates for now
            continue;
        // check if the gate with this functionality already exists
        for ( i = 0; i < iGate; i++ )
            if ( ppGates[i]->uTruth == pGate->uTruth )
            {
                if ( Mio_CompareTwoGates(ppGates[i], pGate) )
                    ppGates[i] = pGate;
                break;
            }
        if ( i < iGate )
            continue;
        assert( iGate < nGates );
        ppGates[ iGate++ ] = pGate;
        if ( fVerbose )
            printf( "Selected gate %3d:   %-20s  A = %7.2f  D = %7.2f  %3s = %-s\n", 
                iGate+1, pGate->pName, pGate->dArea, pGate->dDelayMax, pGate->pOutName, pGate->pForm );
    }
    // sort by delay
    if ( iGate > 0 ) 
    {
        qsort( (void *)ppGates, (size_t)iGate, sizeof(Mio_Gate_t *), 
                (int (*)(const void *, const void *)) Mio_DelayCompare );
        assert( Mio_DelayCompare( ppGates, ppGates + iGate - 1 ) <= 0 );
    }
    if ( pnGates )
        *pnGates = iGate;
    return ppGates;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_CollectRootsNew()

Mio_Cell_t * Mio_CollectRootsNew ( Mio_Library_t * pLib, int nInputs, int * pnGates, int fVerbose )

extern

Definition at line 623 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Cell_t * ppCells;
    int i, nGates, iCell = 4;
    nGates = Mio_LibraryReadGateNum( pLib );
    ppCells = ABC_CALLOC( Mio_Cell_t, nGates + 4 );
    // for each functionality, select gate with the smallest area
    // if equal areas, select gate with smaller average pin delay
    // if these are also equal, select lexicographically smaller name
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs > nInputs || pGate->pTwin ) // skip large and multi-output
            continue;
        // check if the gate with this functionality already exists
        for ( i = 0; i < iCell; i++ )
            if ( ppCells[i].pName && ppCells[i].uTruth == pGate->uTruth )
            {
                if ( Mio_CompareTwo( ppCells + i, pGate ) )
                    Mio_CollectCopy( ppCells + i, pGate );
                break;
            }
        if ( i < iCell )
            continue;
        if ( pGate->uTruth == 0 || pGate->uTruth == ~(word)0 )
        {
            int Idx = (int)(pGate->uTruth == ~(word)0);
            assert( pGate->nInputs == 0 );
            Mio_CollectCopy( ppCells + Idx, pGate );
            continue;
        }
        if ( pGate->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) || pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) )
        {
            int Idx = 2 + (int)(pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA));
            assert( pGate->nInputs == 1 );
            Mio_CollectCopy( ppCells + Idx, pGate );
            continue;
        }
        Mio_CollectCopy( ppCells + iCell++, pGate );
    }
    if ( ppCells[0].pName == NULL )
        { printf( "Error: Cannot find constant 0 gate in the library.\n" ); return NULL; }
    if ( ppCells[1].pName == NULL )
        { printf( "Error: Cannot find constant 1 gate in the library.\n" ); return NULL; }
    if ( ppCells[2].pName == NULL )
        { printf( "Error: Cannot find buffer gate in the library.\n" );     return NULL; }
    if ( ppCells[3].pName == NULL )
        { printf( "Error: Cannot find inverter gate in the library.\n" );   return NULL; }
    // sort by delay
    if ( iCell > 5 ) 
    {
        qsort( (void *)(ppCells + 4), (size_t)(iCell - 4), sizeof(Mio_Cell_t), 
                (int (*)(const void *, const void *)) Mio_AreaCompare );
        assert( Mio_AreaCompare( ppCells + 4, ppCells + iCell - 1 ) <= 0 );
    }
    // assign IDs
    for ( i = 0; i < iCell; i++ )
        ppCells[i].Id = ppCells[i].pName ? i : -1;
 
    // report
    if ( fVerbose )
    {
        // count gates
        int * pCounts = ABC_CALLOC( int, nGates + 4 );
        Mio_LibraryForEachGate( pLib, pGate )
        {
            if ( pGate->nInputs > nInputs || pGate->pTwin ) // skip large and multi-output
                continue;
            for ( i = 0; i < iCell; i++ )
                if ( ppCells[i].pName && ppCells[i].uTruth == pGate->uTruth )
                {
                    pCounts[i]++;
                    break;
                }
            assert( i < iCell );
        }
        for ( i = 0; i < iCell; i++ )
        {
            Mio_Cell_t * pCell = ppCells + i;
            printf( "%4d : ", i );
            if ( pCell->pName == NULL )
                printf( "None\n" );
            else
                printf( "%-20s   In = %d   N = %3d   A = %12.6f   D = %12.6f\n", 
                    pCell->pName, pCell->nFanins, pCounts[i], pCell->Area, Mio_CellDelayAve(pCell) );
        }
        ABC_FREE( pCounts );
    }
    if ( pnGates )
        *pnGates = iCell;
    return ppCells;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_CollectRootsNewDefault()

Mio_Cell_t * Mio_CollectRootsNewDefault ( int nInputs, int * pnGates, int fVerbose )

extern

Definition at line 715 of file mioUtils.c.

{
    return Mio_CollectRootsNew( (Mio_Library_t *)Abc_FrameReadLibGen(), nInputs, pnGates, fVerbose );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_CollectRootsNewDefault2()

Mio_Cell2_t * Mio_CollectRootsNewDefault2 ( int nInputs, int * pnGates, int fVerbose )

extern

Definition at line 877 of file mioUtils.c.

{
    return Mio_CollectRootsNew2( (Mio_Library_t *)Abc_FrameReadLibGen(), nInputs, pnGates, fVerbose );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_CollectRootsNewDefault3()

int Mio_CollectRootsNewDefault3 ( int nInputs, Vec_Ptr_t ** pvNames, Vec_Wrd_t ** pvTruths )

extern

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

Synopsis [Derives the truth table of the gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 893 of file mioUtils.c.

{
    Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
    int i, iGate = 0, nGates = pLib ? Mio_LibraryReadGateNum( pLib ) : 0;
    Mio_Gate_t * pGate0, ** ppGates; word * pTruth;
    if ( pLib == NULL )
        return 0;
    ppGates = ABC_CALLOC( Mio_Gate_t *, nGates );
    Mio_LibraryForEachGate( pLib, pGate0 )
        ppGates[pGate0->Cell] = pGate0;
    *pvNames  = Vec_PtrAlloc( nGates );
    *pvTruths = Vec_WrdStart( nGates * 4 );
    for ( i = 0; i < nGates; i++ )
    {
        pGate0 = ppGates[i];
        if ( pGate0->nInputs > nInputs || pGate0->pTwin ) // skip large and multi-output
            continue;
        Vec_PtrPush( *pvNames, pGate0->pName );
        pTruth = Vec_WrdEntryP( *pvTruths, iGate++*4 );
        if ( pGate0->nInputs <= 6 )
            pTruth[0] = pTruth[1] = pTruth[2] = pTruth[3] = pGate0->uTruth;
        else if ( pGate0->nInputs == 7 )
        {
            pTruth[0] = pTruth[2] = pGate0->pTruth[0];
            pTruth[1] = pTruth[3] = pGate0->pTruth[1];
        }
        else if ( pGate0->nInputs == 8 )
            memcpy( pTruth, pGate0->pTruth, (size_t)(4*sizeof(word)) );
    }
    assert( iGate == nGates );
    assert( Vec_WrdEntry(*pvTruths,  0) ==        0 );
    assert( Vec_WrdEntry(*pvTruths,  4) == ~(word)0 );
    assert( Vec_WrdEntry(*pvTruths,  8) ==  s_Truths6[0] );
    assert( Vec_WrdEntry(*pvTruths, 12) == ~s_Truths6[0] );
    ABC_FREE( ppGates );
    return nGates;
}

Here is the call graph for this function:

Mio_DeriveGateDelays()

void Mio_DeriveGateDelays ( Mio_Gate_t * pGate, float ** ptPinDelays, int nPins, int nInputs, float tDelayZero, float * ptDelaysRes, float * ptPinDelayMax )

extern

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

Synopsis [Derives the area and delay of the root of the gate.]

Description [Array of the resulting delays should be initialized to the (negative) SUPER_NO_VAR value.]

SideEffects []

SeeAlso []

Definition at line 1153 of file mioUtils.c.

{
    Mio_Pin_t * pPin;
    float Delay, DelayMax;
    int i, k;
    assert( pGate->nInputs == nPins );
    // set all the delays to the unused delay
    for ( i = 0; i < nInputs; i++ )
        ptDelaysRes[i] = tDelayZero;
    // compute the delays for each input and the max delay at the same time
    DelayMax = 0;
    for ( i = 0; i < nInputs; i++ )
    {
        for ( k = 0, pPin = pGate->pPins; pPin; pPin = pPin->pNext, k++ )
        {
            if ( ptPinDelays[k][i] < 0 )
                continue;
            Delay = ptPinDelays[k][i] + (float)pPin->dDelayBlockMax;
            if ( ptDelaysRes[i] < Delay )
                ptDelaysRes[i] = Delay;
        }
        if ( k != nPins )
        {
            printf ("DEBUG: problem gate is %s\n", Mio_GateReadName( pGate ));
        }
        assert( k == nPins );
        if ( DelayMax < ptDelaysRes[i] )
            DelayMax = ptDelaysRes[i];
    }
    *ptPinDelayMax = DelayMax;
}

Here is the call graph for this function:

Mio_DeriveTruthTable()

void Mio_DeriveTruthTable ( Mio_Gate_t * pGate, unsigned uTruthsIn[][2], int nSigns, int nInputs, unsigned uTruthRes[] )

extern

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

Synopsis [Derives the truth table of the gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 1036 of file mioUtils.c.

{
    word uRes, uFanins[6];
    int i;
    assert( pGate->nInputs == nSigns );
    for ( i = 0; i < nSigns; i++ )
        uFanins[i] = (((word)uTruthsIn[i][1]) << 32) | (word)uTruthsIn[i][0];
    uRes = Exp_Truth6( nSigns, pGate->vExpr, (word *)uFanins );
    uTruthRes[0] = uRes & 0xFFFFFFFF;
    uTruthRes[1] = uRes >> 32;
}

Here is the caller graph for this function:

Mio_DeriveTruthTable6()

word Mio_DeriveTruthTable6 ( Mio_Gate_t * pGate )

extern

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

Synopsis [Derives the truth table of the gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 942 of file mioUtils.c.

{
    static unsigned uTruths6[6][2] = {
        { 0xAAAAAAAA, 0xAAAAAAAA },
        { 0xCCCCCCCC, 0xCCCCCCCC },
        { 0xF0F0F0F0, 0xF0F0F0F0 },
        { 0xFF00FF00, 0xFF00FF00 },
        { 0xFFFF0000, 0xFFFF0000 },
        { 0x00000000, 0xFFFFFFFF }
    };
    union {
      unsigned u[2];
      word w;
    } uTruthRes;
    assert( pGate->nInputs <= 6 );
    Mio_DeriveTruthTable( pGate, uTruths6, pGate->nInputs, 6, uTruthRes.u );
    return uTruthRes.w;
}

Here is the call graph for this function:

Mio_GateAddToProfile()

void Mio_GateAddToProfile ( Mio_Gate_t * pGate, int Prof )

extern

Definition at line 193 of file mioApi.c.

{ pGate->Profile  += Prof; }

Here is the caller graph for this function:

Mio_GateAddToProfile2()

void Mio_GateAddToProfile2 ( Mio_Gate_t * pGate, int Prof )

extern

Definition at line 194 of file mioApi.c.

{ pGate->Profile2 += Prof; }

Here is the caller graph for this function:

Mio_GateCreatePseudo()

Mio_Gate_t * Mio_GateCreatePseudo ( int nInputs )

extern

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

Synopsis [Creates a pseudo-gate.]

Description [The pseudo-gate is a N-input gate with all info set to 0.]

SideEffects []

SeeAlso []

Definition at line 1199 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    int i;
    // allocate the gate structure
    pGate = ABC_ALLOC( Mio_Gate_t, 1 );
    memset( pGate, 0, sizeof(Mio_Gate_t) );
    pGate->nInputs = nInputs;
    // create pins
    for ( i = 0; i < nInputs; i++ )
    {
        pPin = ABC_ALLOC( Mio_Pin_t, 1 );
        memset( pPin, 0, sizeof(Mio_Pin_t) );
        pPin->pNext = pGate->pPins;
        pGate->pPins = pPin;
    }
    return pGate;
}

Here is the call graph for this function:

Mio_GateDecProfile2()

void Mio_GateDecProfile2 ( Mio_Gate_t * pGate )

extern

Definition at line 192 of file mioApi.c.

{ pGate->Profile2--;       }

Here is the caller graph for this function:

Mio_GateDelete()

void Mio_GateDelete ( Mio_Gate_t * pGate )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 87 of file mioUtils.c.

{
    Mio_Pin_t * pPin, * pPin2;
    if ( pGate->nInputs > 6 )
        ABC_FREE( pGate->pTruth );
    Vec_IntFreeP( &pGate->vExpr );
    ABC_FREE( pGate->pOutName );
    ABC_FREE( pGate->pName );
    ABC_FREE( pGate->pForm );
//    if ( pGate->bFunc )
//        Cudd_RecursiveDeref( pGate->pLib->dd, pGate->bFunc );
    Mio_GateForEachPinSafe( pGate, pPin, pPin2 )
        Mio_PinDelete( pPin );   
    ABC_FREE( pGate );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_GateIncProfile2()

void Mio_GateIncProfile2 ( Mio_Gate_t * pGate )

extern

Definition at line 191 of file mioApi.c.

{ pGate->Profile2++;       }

Here is the caller graph for this function:

Mio_GateIsInv()

int Mio_GateIsInv ( Mio_Gate_t * pGate )

extern

Definition at line 195 of file mioApi.c.

{ return pGate->uTruth == ABC_CONST(0x5555555555555555); }

Here is the caller graph for this function:

Mio_GateReadArea()

double Mio_GateReadArea ( Mio_Gate_t * pGate )

extern

Definition at line 171 of file mioApi.c.

{ return pGate->dArea;     }

Here is the caller graph for this function:

Mio_GateReadCell()

int Mio_GateReadCell ( Mio_Gate_t * pGate )

extern

Definition at line 184 of file mioApi.c.

{ return pGate->Cell;      }

Here is the caller graph for this function:

Mio_GateReadDelayMax()

double Mio_GateReadDelayMax ( Mio_Gate_t * pGate )

extern

Definition at line 178 of file mioApi.c.

{ return pGate->dDelayMax; }

Here is the caller graph for this function:

Mio_GateReadExpr()

Vec_Int_t * Mio_GateReadExpr ( Mio_Gate_t * pGate )

extern

Definition at line 180 of file mioApi.c.

{ return pGate->vExpr;     }

Here is the caller graph for this function:

Mio_GateReadForm()

char * Mio_GateReadForm ( Mio_Gate_t * pGate )

extern

Definition at line 172 of file mioApi.c.

{ return pGate->pForm;     }

Here is the caller graph for this function:

Mio_GateReadLib()

Mio_Library_t * Mio_GateReadLib ( Mio_Gate_t * pGate )

extern

Definition at line 174 of file mioApi.c.

{ return pGate->pLib;      }

Mio_GateReadName()

char * Mio_GateReadName ( Mio_Gate_t * pGate )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 169 of file mioApi.c.

{ return pGate->pName;     }

Here is the caller graph for this function:

Mio_GateReadNext()

Mio_Gate_t * Mio_GateReadNext ( Mio_Gate_t * pGate )

extern

Definition at line 175 of file mioApi.c.

{ return pGate->pNext;     }

Mio_GateReadOutName()

char * Mio_GateReadOutName ( Mio_Gate_t * pGate )

extern

Definition at line 170 of file mioApi.c.

{ return pGate->pOutName;  }

Here is the caller graph for this function:

Mio_GateReadPinDelay()

float Mio_GateReadPinDelay ( Mio_Gate_t * pGate, int iPin )

extern

Definition at line 239 of file mioApi.c.

{
    Mio_Pin_t * pPin;
    int i = 0;
    Mio_GateForEachPin( pGate, pPin )
        if ( i++ == iPin )
            return 0.5 * pPin->dDelayBlockRise + 0.5 * pPin->dDelayBlockFall;
    return ABC_INFINITY;
}

Here is the caller graph for this function:

Mio_GateReadPinName()

char * Mio_GateReadPinName ( Mio_Gate_t * pGate, int iPin )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 230 of file mioApi.c.

{
    Mio_Pin_t * pPin;
    int i = 0;
    Mio_GateForEachPin( pGate, pPin )
        if ( i++ == iPin )
            return Mio_PinReadName(pPin);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_GateReadPinNum()

int Mio_GateReadPinNum ( Mio_Gate_t * pGate )

extern

Definition at line 177 of file mioApi.c.

{ return pGate->nInputs;   }

Here is the caller graph for this function:

Mio_GateReadPins()

Mio_Pin_t * Mio_GateReadPins ( Mio_Gate_t * pGate )

extern

Definition at line 173 of file mioApi.c.

{ return pGate->pPins;     }

Here is the caller graph for this function:

Mio_GateReadProfile()

int Mio_GateReadProfile ( Mio_Gate_t * pGate )

extern

Definition at line 185 of file mioApi.c.

{ return pGate->Profile;   }

Here is the caller graph for this function:

Mio_GateReadProfile2()

int Mio_GateReadProfile2 ( Mio_Gate_t * pGate )

extern

Definition at line 186 of file mioApi.c.

{ return pGate->Profile2;  }

Here is the caller graph for this function:

Mio_GateReadSop()

char * Mio_GateReadSop ( Mio_Gate_t * pGate )

extern

Definition at line 179 of file mioApi.c.

{ return pGate->pSop;      }

Here is the caller graph for this function:

Mio_GateReadTruth()

word Mio_GateReadTruth ( Mio_Gate_t * pGate )

extern

Definition at line 181 of file mioApi.c.

{ return pGate->nInputs <= 6 ? pGate->uTruth : 0;   }

Here is the caller graph for this function:

Mio_GateReadTruthP()

word * Mio_GateReadTruthP ( Mio_Gate_t * pGate )

extern

Definition at line 182 of file mioApi.c.

{ return pGate->nInputs <= 6 ? &pGate->uTruth: pGate->pTruth; }

Here is the caller graph for this function:

Mio_GateReadTwin()

Mio_Gate_t * Mio_GateReadTwin ( Mio_Gate_t * pGate )

extern

Definition at line 176 of file mioApi.c.

{ return pGate->pTwin;     }

Here is the caller graph for this function:

Mio_GateReadValue()

int Mio_GateReadValue ( Mio_Gate_t * pGate )

extern

Definition at line 183 of file mioApi.c.

{ return pGate->Value;     }

Here is the caller graph for this function:

Mio_GateSetCell()

void Mio_GateSetCell ( Mio_Gate_t * pGate, int Cell )

extern

Definition at line 188 of file mioApi.c.

{ pGate->Cell  = Cell;     }

Here is the caller graph for this function:

Mio_GateSetProfile()

void Mio_GateSetProfile ( Mio_Gate_t * pGate, int Prof )

extern

Definition at line 189 of file mioApi.c.

{ pGate->Profile = Prof;   }

Here is the caller graph for this function:

Mio_GateSetProfile2()

void Mio_GateSetProfile2 ( Mio_Gate_t * pGate, int Prof )

extern

Definition at line 190 of file mioApi.c.

{ pGate->Profile2 = Prof;  }

Here is the caller graph for this function:

Mio_GateSetValue()

void Mio_GateSetValue ( Mio_Gate_t * pGate, int Value )

extern

Definition at line 187 of file mioApi.c.

{ pGate->Value = Value;    }

Here is the caller graph for this function:

Mio_LibDeriveSop()

char * Mio_LibDeriveSop ( int nVars, Vec_Int_t * vExpr, Vec_Str_t * vStr )

extern

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

Synopsis [Derives SOP representation.]

Description [The SOP is guaranteed to be SCC-free but not minimal.]

SideEffects []

SeeAlso []

Definition at line 257 of file mioSop.c.

{
    Vec_Int_t * vSop;
    Vec_Ptr_t * vSops0, * vSops1, * vTemp;
    int i, Index0, Index1, fCompl0, fCompl1;
    Vec_StrClear( vStr );
    if ( Exp_IsConst0(vExpr) )
    {
        Vec_StrPrintStr( vStr, " 0\n" );
        Vec_StrPush( vStr, '\0' );
        return Vec_StrArray( vStr );
    }
    if ( Exp_IsConst1(vExpr) )
    {
        Vec_StrPrintStr( vStr, " 1\n" );
        Vec_StrPush( vStr, '\0' );
        return Vec_StrArray( vStr );
    }
    if ( Exp_IsLit(vExpr) )
    {
        for ( i = 0; i < nVars; i++ )
            Vec_StrPush( vStr, '-' );
        Vec_StrPrintStr( vStr, " 1\n" );
        Vec_StrPush( vStr, '\0' );
        assert( (Vec_IntEntry(vExpr,0) >> 1) < nVars );
        Vec_StrWriteEntry( vStr, Vec_IntEntry(vExpr,0) >> 1, (char)('1' - (Vec_IntEntry(vExpr,0) & 1)) );
        return Vec_StrArray( vStr );
    }
    vSops0 = Vec_PtrAlloc( nVars + Exp_NodeNum(vExpr) );
    vSops1 = Vec_PtrAlloc( nVars + Exp_NodeNum(vExpr) );
    for ( i = 0; i < nVars; i++ )
    {
        Vec_PtrPush( vSops0, Mio_SopVar0(i) );
        Vec_PtrPush( vSops1, Mio_SopVar1(i) );
    }
    for ( i = 0; i < Exp_NodeNum(vExpr); i++ )
    {
        Index0  = Vec_IntEntry( vExpr, 2*i+0 ) >> 1;
        Index1  = Vec_IntEntry( vExpr, 2*i+1 ) >> 1;
        fCompl0 = Vec_IntEntry( vExpr, 2*i+0 ) & 1;
        fCompl1 = Vec_IntEntry( vExpr, 2*i+1 ) & 1;
        // positive polarity
        vSop = Mio_SopCoverAnd( fCompl0 ? (Vec_Int_t *)Vec_PtrEntry(vSops0, Index0) : (Vec_Int_t *)Vec_PtrEntry(vSops1, Index0),
                                fCompl1 ? (Vec_Int_t *)Vec_PtrEntry(vSops0, Index1) : (Vec_Int_t *)Vec_PtrEntry(vSops1, Index1) );
        Vec_PtrPush( vSops1, vSop );
        // negative polarity
        vSop = Mio_SopCoverOr( fCompl0 ? (Vec_Int_t *)Vec_PtrEntry(vSops1, Index0) : (Vec_Int_t *)Vec_PtrEntry(vSops0, Index0),
                               fCompl1 ? (Vec_Int_t *)Vec_PtrEntry(vSops1, Index1) : (Vec_Int_t *)Vec_PtrEntry(vSops0, Index1) );
        Vec_PtrPush( vSops0, vSop );
    }
    // complement
    if ( Vec_IntEntryLast(vExpr) & 1 )
    {
        vTemp  = vSops0;
        vSops0 = vSops1;
        vSops1 = vTemp;
    }
    // select the best polarity
    if ( Vec_IntSize( (Vec_Int_t *)Vec_PtrEntryLast(vSops0) ) < Vec_IntSize( (Vec_Int_t *)Vec_PtrEntryLast(vSops1) ) )
        vSop = (Vec_Int_t *)Vec_PtrEntryLast(vSops0);
    else
        vSop = (Vec_Int_t *)Vec_PtrEntryLast(vSops1);
    // convert positive polarity into SOP
    Mio_SopDeriveFromArray( vSop, nVars, vStr, (vSop == Vec_PtrEntryLast(vSops1)) );
    Vec_VecFree( (Vec_Vec_t *)vSops0 );
    Vec_VecFree( (Vec_Vec_t *)vSops1 );
    return Vec_StrArray( vStr );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryCleanProfile2()

void Mio_LibraryCleanProfile2 ( Mio_Library_t * pLib )

extern

Definition at line 1616 of file mioUtils.c.

{
    Mio_Gate_t * pGate;    
    Mio_LibraryForEachGate( pLib, pGate )
        Mio_GateSetProfile2( pGate, 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryDelete()

void Mio_LibraryDelete ( Mio_Library_t * pLib )

extern

DECLARATIONS ///.

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

FileName [mioUtils.c]

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

Synopsis [File reading/writing for technology mapping.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

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

Revision [

Id

mioUtils.c,v 1.6 2004/09/03 18:02:20 satrajit Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 51 of file mioUtils.c.

{
    Mio_Gate_t * pGate, * pGate2;
    if ( pLib == NULL )
        return;
    Mio_LibraryMatchesStop( pLib );
    Mio_LibraryMatches2Stop( pLib );
    // free the bindings of nodes to gates from this library for all networks
    Abc_FrameUnmapAllNetworks( Abc_FrameGetGlobalFrame() );
    // free the library
    ABC_FREE( pLib->pName );
    Mio_LibraryForEachGateSafe( pLib, pGate, pGate2 )
        Mio_GateDelete( pGate );
    Mem_FlexStop( pLib->pMmFlex, 0 );
    Vec_StrFree( pLib->vCube );
    if ( pLib->tName2Gate )
        st__free_table( pLib->tName2Gate );
//    if ( pLib->dd )
//        Cudd_Quit( pLib->dd );
    ABC_FREE( pLib->ppGates0 );
    ABC_FREE( pLib->ppGatesName );
    ABC_FREE( pLib->pFileName );
    ABC_FREE( pLib );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryHasProfile()

int Mio_LibraryHasProfile ( Mio_Library_t * pLib )

extern

Definition at line 1555 of file mioUtils.c.

{
    Mio_Gate_t * pGate;    
    Mio_LibraryForEachGate( pLib, pGate )
        if ( Mio_GateReadProfile(pGate) > 0 )
            return 1;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryMatches2Fetch()

void Mio_LibraryMatches2Fetch ( Mio_Library_t * pLib, Vec_Ptr_t ** pvNames, Vec_Wrd_t ** pvTruths, Vec_Int_t ** pvTt2Match4, Vec_Int_t ** pvConfigs, Vec_Mem_t * pvTtMem2[3], Vec_Int_t * pvTt2Match2[3] )

extern

Definition at line 1830 of file mioUtils.c.

{
    int i;
    Mio_LibraryMatches2Start( pLib );
    *pvNames     = pLib->vNames;    
    *pvTruths    = pLib->vTruths;    
    *pvTt2Match4 = pLib->vTt2Match4;    
    *pvConfigs   = pLib->vConfigs;    
    for ( i = 0; i < 3; i++ )
    {
        pvTtMem2[i]  = pLib->vTtMem2[i];    
        pvTt2Match2[i] = pLib->vTt2Match2[i];   
    }
}

Here is the call graph for this function:

Mio_LibraryMatches2Start()

void Mio_LibraryMatches2Start ( Mio_Library_t * pLib )

extern

Definition at line 1821 of file mioUtils.c.

{
    extern int Gia_ManDeriveMatches( Vec_Ptr_t ** pvNames, Vec_Wrd_t ** pvTruths, Vec_Int_t ** pvTt2Match4, Vec_Int_t ** pvConfigs, Vec_Mem_t * pvTtMem2[3], Vec_Int_t * pvTt2Match2[3] );
    if ( pLib->vNames )
        return;
    if ( pLib->vTtMem )
        Mio_LibraryMatches2Stop( pLib );
    Gia_ManDeriveMatches( &pLib->vNames, &pLib->vTruths, &pLib->vTt2Match4, &pLib->vConfigs, pLib->vTtMem2, pLib->vTt2Match2 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryMatches2Stop()

void Mio_LibraryMatches2Stop ( Mio_Library_t * pLib )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1805 of file mioUtils.c.

{
    int i;
    if ( !pLib->vNames )
        return;
    Vec_PtrFree( pLib->vNames );
    Vec_WrdFree( pLib->vTruths );
    Vec_IntFree( pLib->vTt2Match4 );
    Vec_IntFree( pLib->vConfigs );
    for ( i = 0; i < 3; i++ )
    {
        Vec_MemHashFree( pLib->vTtMem2[i] );
        Vec_MemFree( pLib->vTtMem2[i] );
        Vec_IntFree( pLib->vTt2Match2[i] );
    }
}

Here is the caller graph for this function:

Mio_LibraryMatchesFetch()

void Mio_LibraryMatchesFetch ( Mio_Library_t * pLib, Vec_Mem_t ** pvTtMem, Vec_Wec_t ** pvTt2Match, Mio_Cell2_t ** ppCells, int * pnCells, int fPinFilter, int fPinPerm, int fPinQuick )

extern

Definition at line 1785 of file mioUtils.c.

{
    Mio_LibraryMatchesStart( pLib, fPinFilter, fPinPerm, fPinQuick );
    *pvTtMem    = pLib->vTtMem;     // truth tables
    *pvTt2Match = pLib->vTt2Match;  // matches for truth tables
    *ppCells    = pLib->pCells;     // library gates
    *pnCells    = pLib->nCells;     // library gate count
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryMatchesStart()

void Mio_LibraryMatchesStart ( Mio_Library_t * pLib, int fPinFilter, int fPinPerm, int fPinQuick )

extern

Definition at line 1768 of file mioUtils.c.

{
    extern Mio_Cell2_t * Nf_StoDeriveMatches( Vec_Mem_t * vTtMem, Vec_Wec_t * vTt2Match, int * pnCells, int fPinFilter, int fPinPerm, int fPinQuick );
    if ( pLib->vTtMem && pLib->fPinFilter == fPinFilter && pLib->fPinPerm == fPinPerm && pLib->fPinQuick == fPinQuick )
        return;
    if ( pLib->vTtMem )
        Mio_LibraryMatchesStop( pLib );
    pLib->fPinFilter = fPinFilter;  // pin filtering
    pLib->fPinPerm   = fPinPerm;    // pin permutation
    pLib->fPinQuick  = fPinQuick;   // pin permutation
    pLib->vTtMem     = Vec_MemAllocForTT( 6, 0 );          
    pLib->vTt2Match  = Vec_WecAlloc( 1000 ); 
    Vec_WecPushLevel( pLib->vTt2Match );
    Vec_WecPushLevel( pLib->vTt2Match );
    assert( Vec_WecSize(pLib->vTt2Match) == Vec_MemEntryNum(pLib->vTtMem) );
    pLib->pCells = Nf_StoDeriveMatches( pLib->vTtMem, pLib->vTt2Match, &pLib->nCells, fPinFilter, fPinPerm, fPinQuick );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryMatchesStop()

void Mio_LibraryMatchesStop ( Mio_Library_t * pLib )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1759 of file mioUtils.c.

{
    if ( !pLib->vTtMem )
        return;
    Vec_WecFree( pLib->vTt2Match );
    Vec_MemHashFree( pLib->vTtMem );
    Vec_MemFree( pLib->vTtMem );
    ABC_FREE( pLib->pCells );
}

Here is the caller graph for this function:

Mio_LibraryMultiArea()

void Mio_LibraryMultiArea ( Mio_Library_t * pLib, double Multi )

extern

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

Synopsis [Multiply areas/delays by values proportional to fanin count.]

Description []

SideEffects []

SeeAlso []

Definition at line 1257 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs < 2 )
            continue;
//        printf( "Before %8.3f  ", pGate->dArea );
        pGate->dArea *= pow( pGate->nInputs, Multi );
//        printf( "After %8.3f  Inputs = %d. Factor = %8.3f\n", pGate->dArea, pGate->nInputs, pow( pGate->nInputs, Multi ) );
    }
}

Here is the caller graph for this function:

Mio_LibraryMultiDelay()

void Mio_LibraryMultiDelay ( Mio_Library_t * pLib, double Multi )

extern

Definition at line 1269 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs < 2 )
            continue;
//        printf( "Before %8.3f  ", pGate->dDelayMax );
        pGate->dDelayMax *= pow( pGate->nInputs, Multi );
//        printf( "After %8.3f  Inputs = %d. Factor = %8.3f\n", pGate->dDelayMax, pGate->nInputs, pow( pGate->nInputs, Multi ) );
        Mio_GateForEachPin( pGate, pPin )
        {
            pPin->dDelayBlockRise *= pow( pGate->nInputs, Multi );
            pPin->dDelayBlockFall *= pow( pGate->nInputs, Multi );
            pPin->dDelayBlockMax  *= pow( pGate->nInputs, Multi );
        }
    }
}

Here is the caller graph for this function:

Mio_LibraryParseFormulas()

int Mio_LibraryParseFormulas ( Mio_Library_t * pLib )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Deriving the functionality of the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 58 of file mioForm.c.

{
    Mio_Gate_t * pGate;
 
    // count the gates
    pLib->nGates = 0;
    Mio_LibraryForEachGate( pLib, pGate )
        pLib->nGates++;        
 
    // start a temporary BDD manager
    pLib->dd = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
    // introduce ZDD variables
    Cudd_zddVarsFromBddVars( pLib->dd, 2 );
 
    // for each gate, derive its function
    Mio_LibraryForEachGate( pLib, pGate )
        if ( Mio_GateParseFormula( pGate ) )
            return 1;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryRead()

Mio_Library_t * Mio_LibraryRead ( char * FileName, char * pBuffer, char * ExcludeFile, int nFaninLimit, int fVerbose )

extern

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

Synopsis [Read the genlib type of library.]

Description []

SideEffects []

SeeAlso []

Definition at line 54 of file mioRead.c.

{
    Mio_Library_t * pLib;
    int num;
    char * pBufferCopy;
 
    st__table * tExcludeGate = 0;
 
    if ( ExcludeFile )
    {
        tExcludeGate = st__init_table(strcmp, st__strhash);
        if ( (num = Mio_LibraryReadExclude( ExcludeFile, tExcludeGate )) == -1 )
        {
            st__free_table( tExcludeGate );
            tExcludeGate = 0;
            return 0;
        }
        fprintf ( stdout, "Read %d gates from exclude file\n", num );
    }
 
    pBufferCopy = Abc_UtilStrsav(pBuffer);
    if ( pBuffer == NULL )
        pLib = Mio_LibraryReadOne( FileName, 0, tExcludeGate, nFaninLimit, fVerbose );       // try normal format first ..
    else
    {
        pLib = Mio_LibraryReadBuffer( pBuffer, 0, tExcludeGate, nFaninLimit, fVerbose );       // try normal format first ..
        if ( pLib )
            pLib->pName = Abc_UtilStrsav( Extra_FileNameGenericAppend(FileName, ".genlib") );
    }
    if ( pLib == NULL )
    {
        if ( pBuffer == NULL )
            pLib = Mio_LibraryReadOne( FileName, 1, tExcludeGate, nFaninLimit, fVerbose );       // try normal format first ..
        else
        {
            pLib = Mio_LibraryReadBuffer( pBufferCopy, 1, tExcludeGate, nFaninLimit, fVerbose );       // try normal format first ..
            if ( pLib )
                pLib->pName = Abc_UtilStrsav( Extra_FileNameGenericAppend(FileName, ".genlib") );
        }
        if ( pLib != NULL )
            printf ( "Warning: Read extended genlib format but ignoring extensions\n" );
    }
    ABC_FREE( pBufferCopy );
    if ( tExcludeGate )
        st__free_table( tExcludeGate );
 
    pLib->pFileName = Abc_UtilStrsav( FileName );
    return pLib;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryReadAnd2()

Mio_Gate_t * Mio_LibraryReadAnd2 ( Mio_Library_t * pLib )

extern

Definition at line 54 of file mioApi.c.

{ return pLib->pGateAnd2;  }

Mio_LibraryReadAreaBuf()

float Mio_LibraryReadAreaBuf ( Mio_Library_t * pLib )

extern

Definition at line 66 of file mioApi.c.

{ return (float)(pLib->pGateBuf?   pLib->pGateBuf->dArea   : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadAreaInv()

float Mio_LibraryReadAreaInv ( Mio_Library_t * pLib )

extern

Definition at line 65 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->dArea   : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadAreaNand2()

float Mio_LibraryReadAreaNand2 ( Mio_Library_t * pLib )

extern

Definition at line 67 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->dArea : 0.0); }

Mio_LibraryReadBuf()

Mio_Gate_t * Mio_LibraryReadBuf ( Mio_Library_t * pLib )

extern

Definition at line 49 of file mioApi.c.

{ return pLib->pGateBuf;   }

Here is the caller graph for this function:

Mio_LibraryReadConst0()

Mio_Gate_t * Mio_LibraryReadConst0 ( Mio_Library_t * pLib )

extern

Definition at line 51 of file mioApi.c.

{ return pLib->pGate0;     }

Here is the caller graph for this function:

Mio_LibraryReadConst1()

Mio_Gate_t * Mio_LibraryReadConst1 ( Mio_Library_t * pLib )

extern

Definition at line 52 of file mioApi.c.

{ return pLib->pGate1;     }

Here is the caller graph for this function:

Mio_LibraryReadDelayAigNode()

float Mio_LibraryReadDelayAigNode ( Mio_Library_t * pLib )

extern

Definition at line 64 of file mioApi.c.

{ return pLib->pGateAnd2 ? Mio_LibraryReadDelayAnd2Max(pLib) : Mio_LibraryReadDelayNand2Max(pLib); } // approximate delay of the AIG node

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryReadDelayAnd2Max()

float Mio_LibraryReadDelayAnd2Max ( Mio_Library_t * pLib )

extern

Definition at line 63 of file mioApi.c.

{ return (float)(pLib->pGateAnd2?  pLib->pGateAnd2->pPins->dDelayBlockMax   : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadDelayInvFall()

float Mio_LibraryReadDelayInvFall ( Mio_Library_t * pLib )

extern

Definition at line 58 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockFall   : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadDelayInvMax()

float Mio_LibraryReadDelayInvMax ( Mio_Library_t * pLib )

extern

Definition at line 59 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockMax    : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadDelayInvRise()

float Mio_LibraryReadDelayInvRise ( Mio_Library_t * pLib )

extern

Definition at line 57 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockRise   : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadDelayNand2Fall()

float Mio_LibraryReadDelayNand2Fall ( Mio_Library_t * pLib )

extern

Definition at line 61 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockFall : 0.0); }

Mio_LibraryReadDelayNand2Max()

float Mio_LibraryReadDelayNand2Max ( Mio_Library_t * pLib )

extern

Definition at line 62 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockMax  : 0.0); }

Here is the caller graph for this function:

Mio_LibraryReadDelayNand2Rise()

float Mio_LibraryReadDelayNand2Rise ( Mio_Library_t * pLib )

extern

Definition at line 60 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockRise : 0.0); }

Mio_LibraryReadExclude()

int Mio_LibraryReadExclude ( char * ExcludeFile, st__table * tExcludeGate )

extern

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

Synopsis [populate hash table of gates to be exlcuded from genlib]

Description []

SideEffects []

SeeAlso []

Definition at line 699 of file mioRead.c.

{
    int nDel = 0;
    FILE *pEx;
    char buffer[128];
 
    assert ( tExcludeGate );
 
    if ( ExcludeFile )
    {
        pEx = fopen( ExcludeFile, "r" );
 
        if ( pEx == NULL )
        {
            fprintf ( stdout, "Error: Could not open exclude file %s. Stop.\n", ExcludeFile );
            return -1;
        }
 
        while (1 == fscanf( pEx, "%127s", buffer ))
        {
            //printf ("Read: '%s'\n", buffer );
            st__insert( tExcludeGate, Abc_UtilStrsav( buffer ), (char *)0 );
            nDel++;
        }
 
        fclose( pEx );
    }
 
    return nDel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryReadFileName()

char * Mio_LibraryReadFileName ( Mio_Library_t * pLib )

extern

Definition at line 44 of file mioApi.c.

{ return pLib->pFileName;  }

Here is the caller graph for this function:

Mio_LibraryReadGateArray()

Mio_Gate_t ** Mio_LibraryReadGateArray ( Mio_Library_t * pLib )

extern

Definition at line 47 of file mioApi.c.

{ return pLib->ppGatesName;}

Here is the caller graph for this function:

Mio_LibraryReadGateById()

Mio_Gate_t * Mio_LibraryReadGateById ( Mio_Library_t * pLib, int iD )

extern

Definition at line 48 of file mioApi.c.

{ assert( pLib->ppGates0[Id]->Cell == Id ); return pLib->ppGates0[Id];}

Here is the caller graph for this function:

Mio_LibraryReadGateByName()

Mio_Gate_t * Mio_LibraryReadGateByName ( Mio_Library_t * pLib, char * pName, char * pOutName )

extern

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

Synopsis [Read Mvc of the gate by name.]

Description []

SideEffects []

SeeAlso []

Definition at line 105 of file mioApi.c.

{ 
    Mio_Gate_t * pGate;
    if ( ! st__lookup( pLib->tName2Gate, pName, (char **)&pGate ) )
        return NULL;
    if ( pOutName == NULL )
        return pGate;
    if ( !strcmp(pGate->pOutName, pOutName) )
        return pGate;
    if ( pGate->pTwin && !strcmp(pGate->pTwin->pOutName, pOutName) )
        return pGate->pTwin;
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryReadGateByTruth()

Mio_Gate_t * Mio_LibraryReadGateByTruth ( Mio_Library_t * pLib, word t )

extern

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

Synopsis [Returns the first gate in the library with the given TT.]

Description []

SideEffects []

SeeAlso []

Definition at line 130 of file mioApi.c.

{
    Mio_Gate_t * pGate;
    Mio_LibraryForEachGate( pLib, pGate )
        if ( pGate->nInputs <= 6 && pGate->uTruth == t )
            return pGate;
    return NULL;
}

Here is the caller graph for this function:

Mio_LibraryReadGateNameMax()

int Mio_LibraryReadGateNameMax ( Mio_Library_t * pLib )

extern

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

Synopsis [Returns the longest gate name.]

Description []

SideEffects []

SeeAlso []

Definition at line 81 of file mioApi.c.

{
    Mio_Gate_t * pGate;
    int LenMax = 0, LenCur;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        LenCur = strlen( Mio_GateReadName(pGate) );
        if ( LenMax < LenCur )
            LenMax = LenCur;
    }
    return LenMax;
}

Here is the call graph for this function:

Mio_LibraryReadGateNum()

int Mio_LibraryReadGateNum ( Mio_Library_t * pLib )

extern

Definition at line 45 of file mioApi.c.

{ return pLib->nGates;     }

Here is the caller graph for this function:

Mio_LibraryReadGates()

Mio_Gate_t * Mio_LibraryReadGates ( Mio_Library_t * pLib )

extern

Definition at line 46 of file mioApi.c.

{ return pLib->pGates;     }

Mio_LibraryReadInv()

Mio_Gate_t * Mio_LibraryReadInv ( Mio_Library_t * pLib )

extern

Definition at line 50 of file mioApi.c.

{ return pLib->pGateInv;   }

Here is the caller graph for this function:

Mio_LibraryReadName()

char * Mio_LibraryReadName ( Mio_Library_t * pLib )

extern

DECLARATIONS ///.

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

FileName [mioApi.c]

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

Synopsis [File reading/writing for technology mapping.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

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

Revision [

Id

mioApi.c,v 1.4 2004/06/28 14:20:25 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mioApi.c.

{ return pLib->pName;      }

Here is the caller graph for this function:

Mio_LibraryReadNand2()

Mio_Gate_t * Mio_LibraryReadNand2 ( Mio_Library_t * pLib )

extern

Definition at line 53 of file mioApi.c.

{ return pLib->pGateNand2; }

Here is the caller graph for this function:

Mio_LibraryReadNor2()

Mio_Gate_t * Mio_LibraryReadNor2 ( Mio_Library_t * pLib )

extern

Definition at line 55 of file mioApi.c.

{ return pLib->pGateNor2;  }

Mio_LibraryReadOr2()

Mio_Gate_t * Mio_LibraryReadOr2 ( Mio_Library_t * pLib )

extern

Definition at line 56 of file mioApi.c.

{ return pLib->pGateOr2;   }

Mio_LibraryReadProfile()

void Mio_LibraryReadProfile ( FILE * pFile, Mio_Library_t * pLib )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1523 of file mioUtils.c.

{
    Mio_Gate_t * pGate;    
    char pBuffer[1000];
    while ( fgets( pBuffer, 1000, pFile ) != NULL )
    {
        char * pToken = strtok( pBuffer, " \t\n" );
        if ( pToken == NULL )
            continue;
        if ( pToken[0] == '#' )
            continue;
        // read gate
        pGate = Mio_LibraryReadGateByName( pLib, pToken, NULL );
        if ( pGate == NULL )
        {
            printf( "Cannot find gate \"%s\" in library \"%s\".\n", pToken, Mio_LibraryReadName(pLib) );
            continue;
        }
        // read profile
        pToken = strtok( NULL, " \t\n" );
        Mio_GateSetProfile( pGate, atoi(pToken) );
    }
}

Here is the call graph for this function:

Mio_LibraryReadSopByName()

char * Mio_LibraryReadSopByName ( Mio_Library_t * pLib, char * pName )

extern

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

Synopsis [Read Mvc of the gate by name.]

Description []

SideEffects []

SeeAlso []

Definition at line 150 of file mioApi.c.

{ 
    Mio_Gate_t * pGate;
    if ( st__lookup( pLib->tName2Gate, pName, (char **)&pGate ) )
        return pGate->pSop;
    return NULL;
}

Here is the call graph for this function:

Mio_LibrarySetName()

void Mio_LibrarySetName ( Mio_Library_t * pLib, char * pName )

extern

Definition at line 68 of file mioApi.c.

{ ABC_FREE(pLib->pName); pLib->pName = pName;         }

Here is the caller graph for this function:

Mio_LibraryShiftDelay()

void Mio_LibraryShiftDelay ( Mio_Library_t * pLib, double Shift )

extern

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

Synopsis [Adds constant value to all delay values.]

Description [The pseudo-gate is a N-input gate with all info set to 0.]

SideEffects []

SeeAlso []

Definition at line 1230 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        pGate->dDelayMax += Shift;
        Mio_GateForEachPin( pGate, pPin )
        {
            pPin->dDelayBlockRise += Shift;
            pPin->dDelayBlockFall += Shift;
            pPin->dDelayBlockMax  += Shift;
        }
    }
}

Mio_LibraryShortNames()

void Mio_LibraryShortNames ( Mio_Library_t * pLib )

extern

Definition at line 1711 of file mioUtils.c.

{
    char Buffer[10000];
    Mio_Gate_t * pGate; Mio_Pin_t * pPin;
    int c = 0, i; unsigned char nDigits = (unsigned char)Abc_Base10Log( Mio_LibraryReadGateNum(pLib) );
    // itereate through classes
    Mio_LibraryForEachGate( pLib, pGate )
    {
        ABC_FREE( pGate->pName );
        sprintf( Buffer, "g%0*d", nDigits, ++c );
        pGate->pName = Abc_UtilStrsav( Buffer );
        // update formula
        Mio_LibraryShortFormula( pGate, pGate->pForm, Buffer );
        ABC_FREE( pGate->pForm );
        pGate->pForm = Abc_UtilStrsav( Buffer );
        // pin names
        i = 0;
        Mio_GateForEachPin( pGate, pPin )
        {
            ABC_FREE( pPin->pName );
            sprintf( Buffer, "%c", 'a'+i );
            pPin->pName = Abc_UtilStrsav( Buffer );
            i++;
        }
        // output pin
        ABC_FREE( pGate->pOutName );
        sprintf( Buffer, "z" );
        pGate->pOutName = Abc_UtilStrsav( Buffer );
    }
    Mio_LibraryHashGates( pLib );
    // update library name
    printf( "Renaming library \"%s\" into \"%s%d\".\n", pLib->pName, "lib", Mio_LibraryReadGateNum(pLib) );
    ABC_FREE( pLib->pName );
    sprintf( Buffer, "lib%d", Mio_LibraryReadGateNum(pLib) );
    pLib->pName = Abc_UtilStrsav( Buffer );
}

Here is the call graph for this function:

Mio_LibraryTransferCellIds()

void Mio_LibraryTransferCellIds ( )

extern

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

Synopsis [Install library.]

Description []

SideEffects []

SeeAlso []

Definition at line 1484 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
    SC_Lib * pScl = (SC_Lib *)Abc_FrameReadLibScl();
    int CellId;
    if ( pScl == NULL )
    {
        printf( "SC library cannot be found.\n" );
        return;
    }
    if ( pLib == NULL )
    {
        printf( "Genlib library cannot be found.\n" );
        return;
    }
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( Mio_GateReadPinNum(pGate) == 0 )
            continue;
        CellId = Abc_SclCellFind( pScl, Mio_GateReadName(pGate) );
        if ( CellId < 0 )
            printf( "Cannot find cell ID of gate %s.\n", Mio_GateReadName(pGate) );
        else
            Mio_GateSetCell( pGate, CellId );
    }
}

Here is the call graph for this function:

Mio_LibraryTransferDelays()

void Mio_LibraryTransferDelays ( Mio_Library_t * pLibD, Mio_Library_t * pLibS )

extern

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

Synopsis [Transfers delays from the second to the first.]

Description []

SideEffects []

SeeAlso []

Definition at line 1300 of file mioUtils.c.

{
    Mio_Gate_t * pGateD, * pGateS;
    Mio_Pin_t * pPinD, * pPinS;
    Mio_LibraryForEachGate( pLibS, pGateS )
    {
        Mio_LibraryForEachGate( pLibD, pGateD )
        {
            if ( pGateD->uTruth != pGateS->uTruth )
                continue;
            pPinS = Mio_GateReadPins( pGateS );
            Mio_GateForEachPin( pGateD, pPinD )
            {
                if (pPinS)
                {
                    pPinD->dDelayBlockRise = pPinS->dDelayBlockRise;
                    pPinD->dDelayBlockFall = pPinS->dDelayBlockFall;
                    pPinD->dDelayBlockMax  = pPinS->dDelayBlockMax;
                    pPinS = Mio_PinReadNext(pPinS);
                }
                else
                {
                    pPinD->dDelayBlockRise = 0;
                    pPinD->dDelayBlockFall = 0;
                    pPinD->dDelayBlockMax  = 0;
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryTransferProfile()

void Mio_LibraryTransferProfile ( Mio_Library_t * pLibDst, Mio_Library_t * pLibSrc )

extern

Definition at line 1565 of file mioUtils.c.

{
    Mio_Gate_t * pGateSrc, * pGateDst;    
    Mio_LibraryForEachGate( pLibDst, pGateDst )
        Mio_GateSetProfile( pGateDst, 0 );
    Mio_LibraryForEachGate( pLibSrc, pGateSrc )
        if ( Mio_GateReadProfile(pGateSrc) > 0 )
        {
            // find gate by name
            pGateDst = Mio_LibraryReadGateByName( pLibDst, Mio_GateReadName(pGateSrc), NULL );
            if ( pGateDst == NULL )
            {
                // find gate by function
                Mio_LibraryForEachGate( pLibDst, pGateDst )
                    if ( pGateDst->uTruth == pGateSrc->uTruth )
                        break;
                if ( pGateDst == NULL )
                {
                    printf( "Cannot find gate \"%s\" in library \"%s\".\n", Mio_GateReadName(pGateSrc), Mio_LibraryReadName(pLibDst) );
                    continue;
                }
            }
            Mio_GateAddToProfile( pGateDst, Mio_GateReadProfile(pGateSrc) );
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryTransferProfile2()

void Mio_LibraryTransferProfile2 ( Mio_Library_t * pLibDst, Mio_Library_t * pLibSrc )

extern

Definition at line 1590 of file mioUtils.c.

{
    Mio_Gate_t * pGateSrc, * pGateDst;    
    Mio_LibraryForEachGate( pLibDst, pGateDst )
        Mio_GateSetProfile2( pGateDst, 0 );
    Mio_LibraryForEachGate( pLibSrc, pGateSrc )
        if ( Mio_GateReadProfile2(pGateSrc) > 0 )
        {
            // find gate by name
            pGateDst = Mio_LibraryReadGateByName( pLibDst, Mio_GateReadName(pGateSrc), NULL );
            if ( pGateDst == NULL )
            {
                // find gate by function
                Mio_LibraryForEachGate( pLibDst, pGateDst )
                    if ( pGateDst->uTruth == pGateSrc->uTruth )
                        break;
                if ( pGateDst == NULL )
                {
                    printf( "Cannot find gate \"%s\" in library \"%s\".\n", Mio_GateReadName(pGateSrc), Mio_LibraryReadName(pLibDst) );
                    continue;
                }
            }
            Mio_GateAddToProfile2( pGateDst, Mio_GateReadProfile2(pGateSrc) );
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryWriteProfile()

void Mio_LibraryWriteProfile ( FILE * pFile, Mio_Library_t * pLib )

extern

Definition at line 1547 of file mioUtils.c.

{
    Mio_Gate_t * pGate;    
    Mio_LibraryForEachGate( pLib, pGate )
        if ( Mio_GateReadProfile(pGate) > 0 )
            fprintf( pFile, "%-24s  %6d\n", Mio_GateReadName(pGate), Mio_GateReadProfile(pGate) );
}

Here is the call graph for this function:

Mio_ParseCheckFormula()

int Mio_ParseCheckFormula ( Mio_Gate_t * pGate, char * pForm )

extern

Definition at line 444 of file mioParse.c.

{
    Mio_Pin_t * pPin;
    char * pStr;
    int i, iPin, fVisit[32] = {0};
    if ( Mio_GateReadPins(pGate) == NULL || !strcmp(Mio_PinReadName(Mio_GateReadPins(pGate)), "*") )
        return 1;
/*
    // find the equality sign
    pForm = strstr( pForm, "=" );
    if ( pForm == NULL )
    {
        printf( "Skipping gate \"%s\" because formula \"%s\" has not equality sign (=).\n", pGate->pName, pForm );
        return 0;
    }
*/
//printf( "Checking gate %s\n", pGate->pName );
 
    for ( pStr = pForm; *pStr; pStr++ )
    {
        if ( *pStr == ' ' ||
             *pStr == MIO_EQN_SYM_OPEN ||   
             *pStr == MIO_EQN_SYM_CLOSE ||  
             *pStr == MIO_EQN_SYM_CONST0 || 
             *pStr == MIO_EQN_SYM_CONST1 || 
             *pStr == MIO_EQN_SYM_NEG ||    
             *pStr == MIO_EQN_SYM_NEGAFT || 
             *pStr == MIO_EQN_SYM_AND ||    
             *pStr == MIO_EQN_SYM_AND2 ||   
             *pStr == MIO_EQN_SYM_XOR ||    
             *pStr == MIO_EQN_SYM_OR ||     
             *pStr == MIO_EQN_SYM_OR2 
           )
           continue;
        // return the number of the pin which has this name
        iPin = Mio_ParseCheckName( pGate, &pStr );
        if ( iPin == -1 )
        {
            printf( "Skipping gate \"%s\" because substring \"%s\" does not match with a pin name.\n", pGate->pName, pStr );
            return 0;
        }
        assert( iPin < 32 );
        fVisit[iPin] = 1;
    }
    // check that all pins are used
    for ( pPin = Mio_GateReadPins(pGate), i = 0; pPin; pPin = Mio_PinReadNext(pPin), i++ )
        if ( fVisit[i] == 0 )
        {
//            printf( "Skipping gate \"%s\" because pin \"%s\" does not appear in the formula \"%s\".\n", pGate->pName, Mio_PinReadName(pPin), pForm );
            return 0;
        }
    return 1;
}

Here is the call graph for this function:

Mio_ParseFormula()

Vec_Int_t * Mio_ParseFormula ( char * pFormInit, char ** ppVarNames, int nVars )

extern

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

Synopsis [Derives the AIG corresponding to the equation.]

Description [Takes the stream to output messages, the formula, the vector of variable names and the AIG manager.]

SideEffects []

SeeAlso []

Definition at line 105 of file mioParse.c.

{
    char * pFormula;
    int Man = nVars, * pMan = &Man;
    Vec_Ptr_t * pStackFn;
    Vec_Int_t * pStackOp;
    Vec_Int_t * gFunc;
    char * pTemp, * pName;
    int nParans, fFound, Flag;
    int Oper, Oper1, Oper2;
    int i, v;
 
    // make sure that the number of opening and closing parentheses is the same
    nParans = 0;
    for ( pTemp = pFormInit; *pTemp; pTemp++ )
        if ( *pTemp == '(' )
            nParans++;
        else if ( *pTemp == ')' )
            nParans--;
    if ( nParans != 0 )
    {
        fprintf( stdout, "Mio_ParseFormula(): Different number of opening and closing parentheses ().\n" );
        return NULL;
    }
 
    // copy the formula
    pFormula = ABC_ALLOC( char, strlen(pFormInit) + 3 );
    sprintf( pFormula, "(%s)", pFormInit );
 
    // start the stacks
    pStackFn = Vec_PtrAlloc( 100 );
    pStackOp = Vec_IntAlloc( 100 );
 
    Flag = MIO_EQN_FLAG_START;
    for ( pTemp = pFormula; *pTemp; pTemp++ )
    {
        switch ( *pTemp )
        {
        // skip all spaces, tabs, and end-of-lines
        case ' ':
        case '\t':
        case '\r':
        case '\n':
            continue;
        case MIO_EQN_SYM_CONST0:
            Vec_PtrPush( pStackFn, Exp_Const0() );  // Cudd_Ref( b0 );
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): No operation symbol before constant 0.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            Flag = MIO_EQN_FLAG_VAR; 
            break;
        case MIO_EQN_SYM_CONST1:
            Vec_PtrPush( pStackFn, Exp_Const1() );  //  Cudd_Ref( b1 );
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): No operation symbol before constant 1.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            Flag = MIO_EQN_FLAG_VAR; 
            break;
        case MIO_EQN_SYM_NEG:
            if ( Flag == MIO_EQN_FLAG_VAR )
            {// if NEGBEF follows a variable, AND is assumed
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
                Flag = MIO_EQN_FLAG_OPER;
            }
            Vec_IntPush( pStackOp, MIO_EQN_OPER_NEG );
            break;
        case MIO_EQN_SYM_NEGAFT:
            if ( Flag != MIO_EQN_FLAG_VAR )
            {// if there is no variable before NEGAFT, it is an error
                fprintf( stdout, "Mio_ParseFormula(): No variable is specified before the negation suffix.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            else // if ( Flag == PARSE_FLAG_VAR )
                Vec_PtrPush( pStackFn, Exp_Not( (Vec_Int_t *)Vec_PtrPop(pStackFn) ) );
            break;
        case MIO_EQN_SYM_AND:
        case MIO_EQN_SYM_AND2:
        case MIO_EQN_SYM_OR:
        case MIO_EQN_SYM_OR2:
        case MIO_EQN_SYM_XOR:
            if ( Flag != MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): There is no variable before AND, EXOR, or OR.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            if ( *pTemp == MIO_EQN_SYM_AND || *pTemp == MIO_EQN_SYM_AND2 )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
            else if ( *pTemp == MIO_EQN_SYM_OR || *pTemp == MIO_EQN_SYM_OR2 )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_OR );
            else //if ( *pTemp == MIO_EQN_SYM_XOR )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_XOR );
            Flag = MIO_EQN_FLAG_OPER; 
            break;
        case MIO_EQN_SYM_OPEN:
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
//                fprintf( stdout, "Mio_ParseFormula(): An opening parenthesis follows a var without operation sign.\n" ); 
//                Flag = MIO_EQN_FLAG_ERROR; 
//              break; 
            }
            Vec_IntPush( pStackOp, MIO_EQN_OPER_MARK );
            // after an opening bracket, it feels like starting over again
            Flag = MIO_EQN_FLAG_START; 
            break;
        case MIO_EQN_SYM_CLOSE:
            if ( Vec_IntSize( pStackOp ) != 0 )
            {
                while ( 1 )
                {
                    if ( Vec_IntSize( pStackOp ) == 0 )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): There is no opening parenthesis\n" );
                        Flag = MIO_EQN_FLAG_ERROR; 
                        break;
                    }
                    Oper = Vec_IntPop( pStackOp );
                    if ( Oper == MIO_EQN_OPER_MARK )
                        break;
 
                    // perform the given operation
                    if ( Mio_ParseFormulaOper( pMan, nVars, pStackFn, Oper ) == NULL )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): Unknown operation\n" );
                        ABC_FREE( pFormula );
                        Vec_PtrFreeP( &pStackFn );
                        Vec_IntFreeP( &pStackOp );
                        return NULL;
                    }
                }
            }
            else
            {
                fprintf( stdout, "Mio_ParseFormula(): There is no opening parenthesis\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            if ( Flag != MIO_EQN_FLAG_ERROR )
                Flag = MIO_EQN_FLAG_VAR; 
            break;
 
 
        default:
            // scan the next name
            for ( i = 0; pTemp[i] && 
                         pTemp[i] != ' ' && pTemp[i] != '\t' && pTemp[i] != '\r' && pTemp[i] != '\n' &&
                         pTemp[i] != MIO_EQN_SYM_AND && pTemp[i] != MIO_EQN_SYM_AND2 && pTemp[i] != MIO_EQN_SYM_OR && pTemp[i] != MIO_EQN_SYM_OR2 && 
                         pTemp[i] != MIO_EQN_SYM_XOR && pTemp[i] != MIO_EQN_SYM_NEGAFT && pTemp[i] != MIO_EQN_SYM_CLOSE; 
                  i++ )
              {
                    if ( pTemp[i] == MIO_EQN_SYM_NEG || pTemp[i] == MIO_EQN_SYM_OPEN )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): The negation sign or an opening parenthesis inside the variable name.\n" );
                        Flag = MIO_EQN_FLAG_ERROR; 
                        break;
                    }
              }
            // variable name is found
            fFound = 0;
//            Vec_PtrForEachEntry( char *, vVarNames, pName, v )
            for ( v = 0; v < nVars; v++ )
            {
                pName = ppVarNames[v];
                if ( strncmp(pTemp, pName, i) == 0 && strlen(pName) == (unsigned)i )
                {
                    pTemp += i-1;
                    fFound = 1;
                    break;
                }
            }
            if ( !fFound )
            { 
                fprintf( stdout, "Mio_ParseFormula(): The parser cannot find var \"%s\" in the input var list.\n", pTemp ); 
                Flag = MIO_EQN_FLAG_ERROR; 
                break; 
            }
/*
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): The variable name \"%s\" follows another var without operation sign.\n", pTemp ); 
                Flag = MIO_EQN_FLAG_ERROR; 
                break; 
            }
*/
            if ( Flag == MIO_EQN_FLAG_VAR )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
 
            Vec_PtrPush( pStackFn, Exp_Var(v) ); // Cudd_Ref( pbVars[v] );
            Flag = MIO_EQN_FLAG_VAR; 
            break;
        }
 
        if ( Flag == MIO_EQN_FLAG_ERROR )
            break;      // error exit
        else if ( Flag == MIO_EQN_FLAG_START )
            continue;  //  go on parsing
        else if ( Flag == MIO_EQN_FLAG_VAR )
            while ( 1 )
            {  // check if there are negations in the OpStack     
                if ( Vec_IntSize( pStackOp ) == 0 )
                    break;
                Oper = Vec_IntPop( pStackOp );
                if ( Oper != MIO_EQN_OPER_NEG )
                {
                    Vec_IntPush( pStackOp, Oper );
                    break;
                }
                else
                {
                      Vec_PtrPush( pStackFn, Exp_Not((Vec_Int_t *)Vec_PtrPop(pStackFn)) );
                }
            }
        else // if ( Flag == MIO_EQN_FLAG_OPER )
            while ( 1 )
            {  // execute all the operations in the OpStack
               // with precedence higher or equal than the last one
                Oper1 = Vec_IntPop( pStackOp ); // the last operation
                if ( Vec_IntSize( pStackOp ) == 0 ) 
                {  // if it is the only operation, push it back
                    Vec_IntPush( pStackOp, Oper1 );
                    break;
                }
                Oper2 = Vec_IntPop( pStackOp ); // the operation before the last one
                if ( Oper2 >= Oper1 )  
                {  // if Oper2 precedence is higher or equal, execute it
                    if ( Mio_ParseFormulaOper( pMan, nVars, pStackFn, Oper2 ) == NULL )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): Unknown operation\n" );
                        ABC_FREE( pFormula );
                        Vec_PtrFreeP( &pStackFn );
                        Vec_IntFreeP( &pStackOp );
                        return NULL;
                    }
                    Vec_IntPush( pStackOp,  Oper1 );     // push the last operation back
                }
                else
                {  // if Oper2 precedence is lower, push them back and done
                    Vec_IntPush( pStackOp, Oper2 );
                    Vec_IntPush( pStackOp, Oper1 );
                    break;
                }
            }
    }
 
    if ( Flag != MIO_EQN_FLAG_ERROR )
    {
        if ( Vec_PtrSize(pStackFn) != 0 )
        {    
            gFunc = (Vec_Int_t *)Vec_PtrPop(pStackFn);
            if ( Vec_PtrSize(pStackFn) == 0 )
                if ( Vec_IntSize( pStackOp ) == 0 )
                {
//                    Cudd_Deref( gFunc );
                    ABC_FREE( pFormula );
                    Vec_PtrFreeP( &pStackFn );
                    Vec_IntFreeP( &pStackOp );
                    return Exp_Reverse(gFunc);
                }
                else
                    fprintf( stdout, "Mio_ParseFormula(): Something is left in the operation stack\n" );
            else
                fprintf( stdout, "Mio_ParseFormula(): Something is left in the function stack\n" );
        }
        else
            fprintf( stdout, "Mio_ParseFormula(): The input string is empty\n" );
    }
    ABC_FREE( pFormula );
    Vec_PtrFreeP( &pStackFn );
    Vec_IntFreeP( &pStackOp );
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_ParseFormulaTruth()

Vec_Wrd_t * Mio_ParseFormulaTruth ( char * pFormInit, char ** ppVarNames, int nVars )

extern

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

Synopsis [Derives the TT corresponding to the equation.]

Description []

SideEffects []

SeeAlso []

Definition at line 396 of file mioParse.c.

{
    Vec_Int_t * vExpr;
    Vec_Wrd_t * vTruth;
    // derive expression
    vExpr = Mio_ParseFormula( pFormInit, ppVarNames, nVars );
    if ( vExpr == NULL )
        return NULL;
    // convert it into a truth table
    vTruth = Vec_WrdStart( Abc_Truth6WordNum(nVars) );
    Exp_Truth( nVars, vExpr, Vec_WrdArray(vTruth) );
    Vec_IntFree( vExpr );
    return vTruth;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_PinDelete()

void Mio_PinDelete ( Mio_Pin_t * pPin )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 114 of file mioUtils.c.

{
    ABC_FREE( pPin->pName );
    ABC_FREE( pPin );
}

Here is the caller graph for this function:

Mio_PinDup()

Mio_Pin_t * Mio_PinDup ( Mio_Pin_t * pPin )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 131 of file mioUtils.c.

{
    Mio_Pin_t * pPinNew;
 
    pPinNew = ABC_ALLOC( Mio_Pin_t, 1 );
    *pPinNew = *pPin;
    pPinNew->pName = (pPinNew->pName ? Abc_UtilStrsav(pPinNew->pName) : NULL);
    pPinNew->pNext = NULL;
 
    return pPinNew;
}

Here is the caller graph for this function:

Mio_PinReadDelayBlockFall()

double Mio_PinReadDelayBlockFall ( Mio_Pin_t * pPin )

extern

Definition at line 214 of file mioApi.c.

{ return pPin->dDelayBlockFall; }

Here is the caller graph for this function:

Mio_PinReadDelayBlockMax()

double Mio_PinReadDelayBlockMax ( Mio_Pin_t * pPin )

extern

Definition at line 216 of file mioApi.c.

{ return pPin->dDelayBlockMax;  }

Mio_PinReadDelayBlockRise()

double Mio_PinReadDelayBlockRise ( Mio_Pin_t * pPin )

extern

Definition at line 212 of file mioApi.c.

{ return pPin->dDelayBlockRise; }

Here is the caller graph for this function:

Mio_PinReadDelayFanoutFall()

double Mio_PinReadDelayFanoutFall ( Mio_Pin_t * pPin )

extern

Definition at line 215 of file mioApi.c.

{ return pPin->dDelayFanoutFall;}

Mio_PinReadDelayFanoutRise()

double Mio_PinReadDelayFanoutRise ( Mio_Pin_t * pPin )

extern

Definition at line 213 of file mioApi.c.

{ return pPin->dDelayFanoutRise;}

Mio_PinReadInputLoad()

double Mio_PinReadInputLoad ( Mio_Pin_t * pPin )

extern

Definition at line 210 of file mioApi.c.

{ return pPin->dLoadInput;      }

Mio_PinReadMaxLoad()

double Mio_PinReadMaxLoad ( Mio_Pin_t * pPin )

extern

Definition at line 211 of file mioApi.c.

{ return pPin->dLoadMax;        }

Mio_PinReadName()

char * Mio_PinReadName ( Mio_Pin_t * pPin )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 208 of file mioApi.c.

{ return pPin->pName;           }

Here is the caller graph for this function:

Mio_PinReadNext()

Mio_Pin_t * Mio_PinReadNext ( Mio_Pin_t * pPin )

extern

Definition at line 217 of file mioApi.c.

{ return pPin->pNext;           }

Here is the caller graph for this function:

Mio_PinReadPhase()

Mio_PinPhase_t Mio_PinReadPhase ( Mio_Pin_t * pPin )

extern

Definition at line 209 of file mioApi.c.

{ return pPin->Phase;           }

Here is the caller graph for this function:

Mio_ReadFile()

char * Mio_ReadFile ( char * FileName, int fAddEnd )

extern

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

Synopsis [Read contents of the file.]

Description []

SideEffects []

SeeAlso []

Definition at line 115 of file mioRead.c.

{
    char * pBuffer;
    FILE * pFile;
    int nFileSize;
    int RetValue;
 
    // open the BLIF file for binary reading
    pFile = Io_FileOpen( FileName, "open_path", "rb", 1 );
//    pFile = fopen( FileName, "rb" );
    // if we got this far, file should be okay otherwise would
    // have been detected by caller
    assert ( pFile != NULL );
    // get the file size, in bytes
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile );  
    // move the file current reading position to the beginning
    rewind( pFile ); 
    // load the contents of the file into memory
    pBuffer   = ABC_ALLOC( char, nFileSize + 10 );
    RetValue = fread( pBuffer, nFileSize, 1, pFile );
    // terminate the string with '\0'
    pBuffer[ nFileSize ] = '\0';
    if ( fAddEnd )
        strcat( pBuffer, "\n.end\n" );
    // close file
    fclose( pFile );
    return pBuffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_UpdateGenlib()

void Mio_UpdateGenlib ( Mio_Library_t * pLib )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 243 of file mio.c.

{
    // free the current superlib because it depends on the old Mio library
    if ( Abc_FrameReadLibSuper() )
    {
        Map_SuperLibFree( (Map_SuperLib_t *)Abc_FrameReadLibSuper() );
        Abc_FrameSetLibSuper( NULL );
    }
 
    // replace the current library
    Mio_LibraryDelete( (Mio_Library_t *)Abc_FrameReadLibGen() );
    Abc_FrameSetLibGen( pLib );
 
    // replace the current library
    Amap_LibFree( (Amap_Lib_t *)Abc_FrameReadLibGen2() );
    Abc_FrameSetLibGen2( NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_UpdateGenlib2()

int Mio_UpdateGenlib2 ( Vec_Str_t * vStr, Vec_Str_t * vStr2, char * pFileName, int fVerbose )

extern

Definition at line 260 of file mio.c.

{
    Mio_Library_t * pLib;
    // set the new network
    pLib = Mio_LibraryRead( pFileName, Vec_StrArray(vStr), NULL, 0, fVerbose );  
    if ( pLib == NULL )
        return 0;
 
    // free the current superlib because it depends on the old Mio library
    if ( Abc_FrameReadLibSuper() )
    {
        Map_SuperLibFree( (Map_SuperLib_t *)Abc_FrameReadLibSuper() );
        Abc_FrameSetLibSuper( NULL );
    }
 
    // replace the current library
    Mio_LibraryDelete( (Mio_Library_t *)Abc_FrameReadLibGen() );
    Abc_FrameSetLibGen( pLib );
 
    // set the new network
    pLib = (Mio_Library_t *)Amap_LibReadAndPrepare( pFileName, Vec_StrArray(vStr2), 0, 0 );  
    if ( pLib == NULL )
        return 0;
 
    // replace the current library
    Amap_LibFree( (Amap_Lib_t *)Abc_FrameReadLibGen2() );
    Abc_FrameSetLibGen2( pLib );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_WriteLibrary()

void Mio_WriteLibrary ( FILE * pFile, Mio_Library_t * pLib, int fPrintSops, int fShort, int fSelected )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 262 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    Vec_Ptr_t * vGates = Vec_PtrAlloc( 1000 );
    int i, nCells, GateLen = 0, NameLen = 0, FormLen = 0;
    int fAllPins = fShort || Mio_CheckGates( pLib );
    if ( fSelected )
    {
        Mio_Cell2_t * pCells = Mio_CollectRootsNewDefault2( 6, &nCells, 0 );
        for ( i = 0; i < nCells; i++ )
            Vec_PtrPush( vGates, pCells[i].pMioGate );
        ABC_FREE( pCells );
    }
    else
    {
        for ( i = 0; i < pLib->nGates; i++ )
            Vec_PtrPush( vGates, pLib->ppGates0[i] );
    }
    Vec_PtrForEachEntry( Mio_Gate_t *, vGates, pGate, i )
    {
        GateLen = Abc_MaxInt( GateLen, strlen(pGate->pName) );
        NameLen = Abc_MaxInt( NameLen, strlen(pGate->pOutName) );
        FormLen = Abc_MaxInt( FormLen, strlen(pGate->pForm) );
        Mio_GateForEachPin( pGate, pPin )
            NameLen = Abc_MaxInt( NameLen, strlen(pPin->pName) );
    }
    fprintf( pFile, "# The genlib library \"%s\" with %d gates written by ABC on %s\n", pLib->pName, Vec_PtrSize(vGates), Extra_TimeStamp() );
    Vec_PtrForEachEntry( Mio_Gate_t *, vGates, pGate, i )
        Mio_WriteGate( pFile, pGate, GateLen, NameLen, FormLen, fPrintSops, fAllPins );
    Vec_PtrFree( vGates );
}

Here is the call graph for this function:

Mio_WriteLibraryVerilog()

void Mio_WriteLibraryVerilog ( FILE * pFile, Mio_Library_t * pLib, int fPrintSops, int fShort, int fSelected )

extern

Definition at line 357 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    Vec_Ptr_t * vGates = Vec_PtrAlloc( 1000 );
    Vec_Ptr_t * vNames = Vec_PtrAlloc( 100 );
    int i, nCells;
    if ( fSelected )
    {
        Mio_Cell2_t * pCells = Mio_CollectRootsNewDefault2( 6, &nCells, 0 );
        for ( i = 0; i < nCells; i++ )
            Vec_PtrPush( vGates, pCells[i].pMioGate );
        ABC_FREE( pCells );
    }
    else
    {
        for ( i = 0; i < pLib->nGates; i++ )
            Vec_PtrPush( vGates, pLib->ppGates0[i] );
    }
    fprintf( pFile, "// Verilog for genlib library \"%s\" with %d gates written by ABC on %s\n\n", pLib->pName, Vec_PtrSize(vGates), Extra_TimeStamp() );
    Vec_PtrForEachEntry( Mio_Gate_t *, vGates, pGate, i )
    {
        Vec_PtrClear( vNames );
        Mio_GateForEachPin( pGate, pPin )
            Vec_PtrPush( vNames, pPin->pName );
        Mio_WriteGateVerilog( pFile, pGate, vNames );
    }
    Vec_PtrFree( vNames );
    Vec_PtrFree( vGates );
}

Here is the call graph for this function: