abcPrint.c File Reference

#include <math.h>
#include "base/abc/abc.h"
#include "bool/dec/dec.h"
#include "base/main/main.h"
#include "map/mio/mio.h"
#include "aig/aig/aig.h"
#include "map/if/if.h"

Include dependency graph for abcPrint.c:

Go to the source code of this file.

Functions
int	Abc_NtkCompareAndSaveBest (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///.
double	Abc_NtkMemory (Abc_Ntk_t *p)
float	Abc_NtkMfsTotalSwitching (Abc_Ntk_t *pNtk)
float	Abc_NtkGetArea (Abc_Ntk_t *pNtk)
float	Abc_NtkGetAreaSpecial (Abc_Ntk_t *pNtk)
float	Abc_NtkGetAreaSpecial2 (Abc_Ntk_t *pNtk)
void	Abc_NtkPrintStats (Abc_Ntk_t *pNtk, int fFactored, int fSaveBest, int fDumpResult, int fUseLutLib, int fPrintMuxes, int fPower, int fGlitch, int fSkipBuf, int fSkipSmall, int fPrintMem)
void	Abc_NtkPrintIo (FILE *pFile, Abc_Ntk_t *pNtk, int fPrintFlops)
void	Abc_NtkPrintLatch (FILE *pFile, Abc_Ntk_t *pNtk)
void	Abc_NtkFaninFanoutCounters (Abc_Ntk_t *pNtk, Vec_Int_t *vFan, Vec_Int_t *vFon, Vec_Int_t *vFanR, Vec_Int_t *vFonR)
void	Abc_NtkInputOutputCounters (Abc_Ntk_t *pNtk, Vec_Int_t *vFan, Vec_Int_t *vFon, Vec_Int_t *vFanR, Vec_Int_t *vFonR)
Vec_Int_t *	Abc_NtkCollectCoSupps (Abc_Ntk_t *pNtk, int fVerbose)
Vec_Int_t *	Abc_NtkCollectCiSupps (Abc_Ntk_t *pNtk, int fVerbose)
void	Abc_NtkInOutSupportCounters (Abc_Ntk_t *pNtk, Vec_Int_t *vFan, Vec_Int_t *vFon, Vec_Int_t *vFanR, Vec_Int_t *vFonR)
Vec_Int_t *	Abc_NtkCollectCoCones (Abc_Ntk_t *pNtk, int fVerbose)
Vec_Int_t *	Abc_NtkCollectCiCones (Abc_Ntk_t *pNtk, int fVerbose)
void	Abc_NtkInOutConeCounters (Abc_Ntk_t *pNtk, Vec_Int_t *vFan, Vec_Int_t *vFon, Vec_Int_t *vFanR, Vec_Int_t *vFonR)
void	Abc_NtkPrintDistribInternal (FILE *pFile, Abc_Ntk_t *pNtk, char *pFanins, char *pFanouts, char *pNode, char *pFanin, char *pFanout, Vec_Int_t *vFan, Vec_Int_t *vFon, Vec_Int_t *vFanR, Vec_Int_t *vFonR)
void	Abc_NtkPrintFanio (FILE *pFile, Abc_Ntk_t *pNtk, int fUseFanio, int fUsePio, int fUseSupp, int fUseCone)
void	Abc_NtkPrintFanioNew (FILE *pFile, Abc_Ntk_t *pNtk, int fMffc)
void	Abc_NodePrintFanio (FILE *pFile, Abc_Obj_t *pNode)
void	Abc_NtkPrintMffc (FILE *pFile, Abc_Ntk_t *pNtk)
void	Abc_NodePrintFactor (FILE *pFile, Abc_Obj_t *pNode, int fUseRealNames)
void	Abc_NtkPrintFactor (FILE *pFile, Abc_Ntk_t *pNtk, int fUseRealNames)
void	Abc_NodePrintSop (FILE *pFile, Abc_Obj_t *pNode, int fUseRealNames)
void	Abc_NtkPrintSop (FILE *pFile, Abc_Ntk_t *pNtk, int fUseRealNames)
char *	Abc_NodeGetPrintName (Abc_Obj_t *pObj)
void	Abc_NtkPrintLevel (FILE *pFile, Abc_Ntk_t *pNtk, int fProfile, int fListNodes, int fOutputs, int fVerbose)
void	Abc_NodePrintLevel (FILE *pFile, Abc_Obj_t *pNode)
void	Abc_NodePrintKMap (Abc_Obj_t *pNode, int fUseRealNames)
void	Abc_NtkPrintGates (Abc_Ntk_t *pNtk, int fUseLibrary, int fUpdateProfile)
void	Abc_NtkPrintSharing (Abc_Ntk_t *pNtk)
int	Abc_NtkCountPis (Vec_Ptr_t *vSupp)
void	Abc_NtkPrintStrSupports (Abc_Ntk_t *pNtk, int fMatrix)
void	Abc_ObjPrint (FILE *pFile, Abc_Obj_t *pObj)
void	Abc_NtkPrintMiter (Abc_Ntk_t *pNtk)
void	Abc_NtkPrintPoEquivs (Abc_Ntk_t *pNtk)
Gli_Man_t *	Gli_ManAlloc (int nObjs, int nRegs, int nFanioPairs)
	FUNCTION DEFINITIONS ///.
void	Gli_ManStop (Gli_Man_t *p)
int	Gli_ManCreateCi (Gli_Man_t *p, int nFanouts)
int	Gli_ManCreateCo (Gli_Man_t *p, int iFanin)
int	Gli_ManCreateNode (Gli_Man_t *p, Vec_Int_t *vFanins, int nFanouts, word *pGateTruth)
void	Gli_ManSwitchesAndGlitches (Gli_Man_t *p, int nPatterns, float PiTransProb, int fVerbose)
int	Gli_ObjNumSwitches (Gli_Man_t *p, int iNode)
int	Gli_ObjNumGlitches (Gli_Man_t *p, int iNode)
float	Abc_NtkMfsTotalGlitchingLut (Abc_Ntk_t *pNtk, int nPats, int Prob, int fVerbose)
float	Abc_NtkMfsTotalGlitching (Abc_Ntk_t *pNtk, int nPats, int Prob, int fVerbose)
void	Abc_Show6VarFunc (word F0, word F1)
void	Abc_NtkShow6VarFunc (char *pF0, char *pF1)

Variables
ABC_NAMESPACE_IMPL_START abctime	s_MappingTime = 0
	DECLARATIONS ///.
int	s_MappingMem = 0
abctime	s_ResynTime = 0

Function Documentation

Abc_NodeGetPrintName()

char * Abc_NodeGetPrintName

(

Abc_Obj_t *

pObj

)

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

Synopsis [Prints the level stats of the PO node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1220 of file abcPrint.c.

{
    Abc_Obj_t * pFan, * pFanout = NULL; int k, nPos = 0;
    if ( !Abc_ObjIsNode(pObj) ) 
        return Abc_ObjName(pObj);
    Abc_ObjForEachFanout( pObj, pFan, k ) {
        if ( Abc_ObjIsPo(pFan) )
            pFanout = pFan, nPos++;
    }
    return Abc_ObjName(nPos == 1 ? pFanout : pObj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodePrintFactor()

void Abc_NodePrintFactor	(	FILE *	pFile,
		Abc_Obj_t *	pNode,
		int	fUseRealNames )

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

Synopsis [Prints the factored form of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1101 of file abcPrint.c.

{
    Dec_Graph_t * pGraph;
    Vec_Ptr_t * vNamesIn;
    if ( Abc_ObjIsCo(pNode) )
        pNode = Abc_ObjFanin0(pNode);
    if ( Abc_ObjIsPi(pNode) )
    {
        fprintf( pFile, "Skipping the PI node.\n" );
        return;
    }
    if ( Abc_ObjIsLatch(pNode) )
    {
        fprintf( pFile, "Skipping the latch.\n" );
        return;
    }
    assert( Abc_ObjIsNode(pNode) );
    pGraph = Dec_Factor( (char *)pNode->pData );
    if ( fUseRealNames )
    {
        vNamesIn = Abc_NodeGetFaninNames(pNode);
        Dec_GraphPrint( stdout, pGraph, (char **)vNamesIn->pArray, Abc_ObjName(pNode) );
        Abc_NodeFreeNames( vNamesIn );
    }
    else
        Dec_GraphPrint( stdout, pGraph, (char **)NULL, Abc_ObjName(pNode) );
    Dec_GraphFree( pGraph );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodePrintFanio()

void Abc_NodePrintFanio	(	FILE *	pFile,
		Abc_Obj_t *	pNode )

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

Synopsis [Prints the fanins/fanouts of a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1048 of file abcPrint.c.

{
    Abc_Obj_t * pNode2;
    int i;
    if ( Abc_ObjIsPo(pNode) )
        pNode = Abc_ObjFanin0(pNode);
 
    fprintf( pFile, "Node %s", Abc_ObjName(pNode) );
    fprintf( pFile, "\n" );
 
    fprintf( pFile, "Fanins (%d): ", Abc_ObjFaninNum(pNode) );
    Abc_ObjForEachFanin( pNode, pNode2, i )
        fprintf( pFile, " %s", Abc_ObjName(pNode2) );
    fprintf( pFile, "\n" );
 
    fprintf( pFile, "Fanouts (%d): ", Abc_ObjFaninNum(pNode) );
    Abc_ObjForEachFanout( pNode, pNode2, i )
        fprintf( pFile, " %s", Abc_ObjName(pNode2) );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Abc_NodePrintKMap()

void Abc_NodePrintKMap	(	Abc_Obj_t *	pNode,
		int	fUseRealNames )

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

Synopsis [Prints the factored form of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1401 of file abcPrint.c.

{
#ifdef ABC_USE_CUDD
    Vec_Ptr_t * vNamesIn;
    if ( fUseRealNames )
    {
        vNamesIn = Abc_NodeGetFaninNames(pNode);
        Extra_PrintKMap( stdout, (DdManager *)pNode->pNtk->pManFunc, (DdNode *)pNode->pData, Cudd_Not(pNode->pData),
            Abc_ObjFaninNum(pNode), NULL, 0, (char **)vNamesIn->pArray );
        Abc_NodeFreeNames( vNamesIn );
    }
    else
        Extra_PrintKMap( stdout, (DdManager *)pNode->pNtk->pManFunc, (DdNode *)pNode->pData, Cudd_Not(pNode->pData),
            Abc_ObjFaninNum(pNode), NULL, 0, NULL );
#endif
}

Here is the call graph for this function:

Abc_NodePrintLevel()

void Abc_NodePrintLevel	(	FILE *	pFile,
		Abc_Obj_t *	pNode )

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

Synopsis [Prints the factored form of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1358 of file abcPrint.c.

{
    Abc_Obj_t * pDriver;
    Vec_Ptr_t * vNodes;
 
    pDriver = Abc_ObjIsCo(pNode)? Abc_ObjFanin0(pNode) : pNode;
    if ( Abc_ObjIsPi(pDriver) )
    {
        fprintf( pFile, "Primary input.\n" );
        return;
    }
    if ( Abc_ObjIsLatch(pDriver) )
    {
        fprintf( pFile, "Latch.\n" );
        return;
    }
    if ( Abc_NodeIsConst(pDriver) )
    {
        fprintf( pFile, "Constant %d.\n", !Abc_ObjFaninC0(pNode) );
        return;
    }
    // print the level
    fprintf( pFile, "Level = %3d.  ", pDriver->Level );
    // print the size of MFFC
    fprintf( pFile, "Mffc = %5d.  ", Abc_NodeMffcSize(pDriver) );
    // print the size of the shole cone
    vNodes = Abc_NtkDfsNodes( pNode->pNtk, &pDriver, 1 );
    fprintf( pFile, "Cone = %5d.  ", Vec_PtrSize(vNodes) );
    Vec_PtrFree( vNodes );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodePrintSop()

void Abc_NodePrintSop	(	FILE *	pFile,
		Abc_Obj_t *	pNode,
		int	fUseRealNames )

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

Synopsis [Prints the SOPs of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1149 of file abcPrint.c.

{
    Vec_Ptr_t * vNamesIn = NULL;
    char * pCube, * pCur, * pSop; int nVars;
    if ( Abc_ObjIsCo(pNode) )
        pNode = Abc_ObjFanin0(pNode);
    if ( Abc_ObjIsPi(pNode) )
    {
        fprintf( pFile, "Skipping the PI node.\n" );
        return;
    }
    if ( Abc_ObjIsLatch(pNode) )
    {
        fprintf( pFile, "Skipping the latch.\n" );
        return;
    }
    assert( Abc_ObjIsNode(pNode) );
    pSop = (char *)pNode->pData;
    nVars = Abc_SopGetVarNum( pSop );
    if ( nVars == 0 )
    {
        fprintf( pFile, "%s = ", Abc_ObjName(pNode) );
        fprintf( pFile, "Constant %d", Abc_SopGetPhase(pSop) );
        return;
    }
    if ( !Abc_SopGetPhase(pSop) )
        fprintf( pFile, "!" );
    fprintf( pFile, "%s = ", Abc_ObjName(pNode) );
    if ( fUseRealNames )
        vNamesIn = Abc_NodeGetFaninNames(pNode);
    Abc_SopForEachCube( pSop, nVars, pCube )
    {
        if ( pCube != pSop ) 
            fprintf( pFile, " +" );
        if ( vNamesIn )
        {
            for ( pCur = pCube; *pCur != ' '; pCur++ )
                if ( *pCur != '-' )
                    fprintf( pFile, " %s%s", *pCur == '0' ? "!" : "",  (char *)Vec_PtrEntry(vNamesIn, pCur-pCube) );
        }
        else
        {
            for ( pCur = pCube; *pCur != ' '; pCur++ )
                if ( *pCur != '-' )
                    fprintf( pFile, " %s%c", *pCur == '0' ? "!" : "",  (char)('a' + pCur-pCube) );
        }
    }
    fprintf( pFile, "\n" );
    if ( vNamesIn )
        Abc_NodeFreeNames( vNamesIn );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkCollectCiCones()

Vec_Int_t * Abc_NtkCollectCiCones	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

Definition at line 782 of file abcPrint.c.

{
    abctime clk = Abc_Clock();
    Abc_Obj_t * pNode; int i, k;
    Vec_Ptr_t * vNodes = Abc_NtkDfs( pNtk, 0 );
    Vec_Int_t * vFanin, * vFanout, * vTemp = Vec_IntAlloc( 0 );
    Vec_Int_t * vSuppsCi = Vec_IntAlloc( Abc_NtkCiNum(pNtk) );
    Vec_Wec_t * vSupps = Vec_WecStart( Abc_NtkObjNumMax(pNtk) );
    Vec_PtrForEachEntryReverse( Abc_Obj_t *, vNodes, pNode, i )
    {
        vFanout = Vec_WecEntry(vSupps, Abc_ObjId(pNode));
        Vec_IntPush( vFanout, i );
        for ( k = 0; k < Abc_ObjFaninNum(pNode); k++ )
        {
            vFanin = Vec_WecEntry(vSupps, Abc_ObjFaninId(pNode, k));
            Vec_IntTwoMerge2( vFanin, vFanout, vTemp );
            ABC_SWAP( Vec_Int_t, *vFanin, *vTemp );
        }
    }
    Abc_NtkForEachCi( pNtk, pNode, i )
        Vec_IntPush( vSuppsCi, Vec_IntSize(Vec_WecEntry(vSupps, Abc_ObjId(pNode))) );
    Vec_WecFree( vSupps );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vTemp );
    if ( fVerbose )
        Abc_PrintTime( 1, "Output cone computation", Abc_Clock() - clk );
    //Vec_IntPrint( vSuppsCi );
    return vSuppsCi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkCollectCiSupps()

Vec_Int_t * Abc_NtkCollectCiSupps	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

Definition at line 689 of file abcPrint.c.

{
    abctime clk = Abc_Clock();
    Abc_Obj_t * pNode; int i, k;
    Vec_Ptr_t * vNodes = Abc_NtkDfs( pNtk, 0 );
    Vec_Int_t * vFanin, * vFanout, * vTemp = Vec_IntAlloc( 0 );
    Vec_Int_t * vSuppsCi = Vec_IntAlloc( Abc_NtkCiNum(pNtk) );
    Vec_Wec_t * vSupps = Vec_WecStart( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        vFanout = Vec_WecEntry(vSupps, Abc_ObjId(pNode));
        vFanin = Vec_WecEntry(vSupps, Abc_ObjFaninId0(pNode));
        Vec_IntPush( vFanout, i );
        Vec_IntTwoMerge2( vFanin, vFanout, vTemp );
        ABC_SWAP( Vec_Int_t, *vFanin, *vTemp );
    }
    Vec_PtrForEachEntryReverse( Abc_Obj_t *, vNodes, pNode, i )
    {
        vFanout = Vec_WecEntry(vSupps, Abc_ObjId(pNode));
        for ( k = 0; k < Abc_ObjFaninNum(pNode); k++ )
        {
            vFanin = Vec_WecEntry(vSupps, Abc_ObjFaninId(pNode, k));
            Vec_IntTwoMerge2( vFanin, vFanout, vTemp );
            ABC_SWAP( Vec_Int_t, *vFanin, *vTemp );
        }
    }
    Abc_NtkForEachCi( pNtk, pNode, i )
        Vec_IntPush( vSuppsCi, Vec_IntSize(Vec_WecEntry(vSupps, Abc_ObjId(pNode))) );
    Vec_WecFree( vSupps );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vTemp );
    if ( fVerbose )
        Abc_PrintTime( 1, "Output support computation", Abc_Clock() - clk );
    //Vec_IntPrint( vSuppsCi );
    return vSuppsCi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkCollectCoCones()

Vec_Int_t * Abc_NtkCollectCoCones	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

Definition at line 753 of file abcPrint.c.

{
    abctime clk = Abc_Clock();
    Abc_Obj_t * pNode; int i, k;
    Vec_Ptr_t * vNodes = Abc_NtkDfs( pNtk, 0 );
    Vec_Int_t * vFanin, * vFanout, * vTemp = Vec_IntAlloc( 0 );
    Vec_Int_t * vSuppsCo = Vec_IntAlloc( Abc_NtkCoNum(pNtk) );
    Vec_Wec_t * vSupps = Vec_WecStart( Abc_NtkObjNumMax(pNtk) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        vFanout = Vec_WecEntry(vSupps, Abc_ObjId(pNode));
        for ( k = 0; k < Abc_ObjFaninNum(pNode); k++ )
        {
            vFanin = Vec_WecEntry(vSupps, Abc_ObjFaninId(pNode, k));
            Vec_IntTwoMerge2( vFanout, vFanin, vTemp ); 
            ABC_SWAP( Vec_Int_t, *vFanout, *vTemp );
        }
        Vec_IntPush( vFanout, i );
    }
    Abc_NtkForEachCo( pNtk, pNode, i )
        Vec_IntPush( vSuppsCo, Vec_IntSize(Vec_WecEntry(vSupps, Abc_ObjFaninId0(pNode))) );
    Vec_WecFree( vSupps );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vTemp );
    if ( fVerbose )
        Abc_PrintTime( 1, "Input  cone computation", Abc_Clock() - clk );
    //Vec_IntPrint( vSuppsCo );
    return vSuppsCo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkCollectCoSupps()

Vec_Int_t * Abc_NtkCollectCoSupps	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

Definition at line 659 of file abcPrint.c.

{
    abctime clk = Abc_Clock();
    Abc_Obj_t * pNode; int i, k;
    Vec_Ptr_t * vNodes = Abc_NtkDfs( pNtk, 0 );
    Vec_Int_t * vFanin, * vFanout, * vTemp = Vec_IntAlloc( 0 );
    Vec_Int_t * vSuppsCo = Vec_IntAlloc( Abc_NtkCoNum(pNtk) );
    Vec_Wec_t * vSupps = Vec_WecStart( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachCi( pNtk, pNode, i )
        Vec_IntPush( Vec_WecEntry(vSupps, Abc_ObjId(pNode)), i );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        vFanout = Vec_WecEntry(vSupps, Abc_ObjId(pNode));
        for ( k = 0; k < Abc_ObjFaninNum(pNode); k++ )
        {
            vFanin = Vec_WecEntry(vSupps, Abc_ObjFaninId(pNode, k));
            Vec_IntTwoMerge2( vFanout, vFanin, vTemp ); 
            ABC_SWAP( Vec_Int_t, *vFanout, *vTemp );
        }
    }
    Abc_NtkForEachCo( pNtk, pNode, i )
        Vec_IntPush( vSuppsCo, Vec_IntSize(Vec_WecEntry(vSupps, Abc_ObjFaninId0(pNode))) );
    Vec_WecFree( vSupps );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vTemp );
    if ( fVerbose )
        Abc_PrintTime( 1, "Input  support computation", Abc_Clock() - clk );
    //Vec_IntPrint( vSuppsCo );
    return vSuppsCo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkCompareAndSaveBest()

int Abc_NtkCompareAndSaveBest

(

Abc_Ntk_t *

pNtk

)

FUNCTION DEFINITIONS ///.

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

Synopsis [If the network is best, saves it in "best.blif" and returns 1.]

Description [If the networks are incomparable, saves the new network, returns its parameters in the internal parameter structure, and returns 1. If the new network is not a logic network, quits without saving and returns 0.]

SideEffects []

SeeAlso []

Definition at line 69 of file abcPrint.c.

{
    extern void Io_Write( Abc_Ntk_t * pNtk, char * pFileName, Io_FileType_t FileType );
    static struct ParStruct {
        char * pName;  // name of the best saved network
        int    Depth;  // depth of the best saved network
        int    Flops;  // flops in the best saved network 
        int    Nodes;  // nodes in the best saved network
        int    Edges;  // edges in the best saved network
        int    nPis;   // the number of primary inputs
        int    nPos;   // the number of primary outputs
    } ParsNew, ParsBest = { 0 };
    char * pFileNameOut;
    // free storage for the name
    if ( pNtk == NULL )
    {
        ABC_FREE( ParsBest.pName );
        return 0;
    }
    // quit if not a logic network
    if ( !Abc_NtkIsLogic(pNtk) )
        return 0;
    // get the parameters
    ParsNew.Depth = Abc_NtkLevel( pNtk );
    ParsNew.Flops = Abc_NtkLatchNum( pNtk );
    ParsNew.Nodes = Abc_NtkNodeNum( pNtk );
    ParsNew.Edges = Abc_NtkGetTotalFanins( pNtk );
    ParsNew.nPis  = Abc_NtkPiNum( pNtk );
    ParsNew.nPos  = Abc_NtkPoNum( pNtk );
    // reset the parameters if the network has the same name
    if (  ParsBest.pName == NULL ||
          strcmp(ParsBest.pName, pNtk->pName) ||
          ParsBest.Depth >  ParsNew.Depth ||
         (ParsBest.Depth == ParsNew.Depth && ParsBest.Flops >  ParsNew.Flops) ||
         (ParsBest.Depth == ParsNew.Depth && ParsBest.Flops == ParsNew.Flops && ParsBest.Edges >  ParsNew.Edges) )
    {
        ABC_FREE( ParsBest.pName );
        ParsBest.pName = Extra_UtilStrsav( pNtk->pName );
        ParsBest.Depth = ParsNew.Depth;
        ParsBest.Flops = ParsNew.Flops;
        ParsBest.Nodes = ParsNew.Nodes;
        ParsBest.Edges = ParsNew.Edges;
        ParsBest.nPis  = ParsNew.nPis;
        ParsBest.nPos  = ParsNew.nPos;
        // writ the network
        if ( strcmp(pNtk->pSpec + strlen(pNtk->pSpec) - strlen("_best.blif"), "_best.blif") )
            pFileNameOut = Extra_FileNameGenericAppend( pNtk->pSpec, "_best.blif" );
        else
            pFileNameOut = pNtk->pSpec;
        Io_Write( pNtk, pFileNameOut, IO_FILE_BLIF );
        return 1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkCountPis()

int Abc_NtkCountPis

(

Vec_Ptr_t *

vSupp

)

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

Synopsis [Prints info for each output cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 1612 of file abcPrint.c.

{
    Abc_Obj_t * pObj;
    int i, Counter = 0;
    Vec_PtrForEachEntry( Abc_Obj_t *, vSupp, pObj, i )
        Counter += Abc_ObjIsPi(pObj);
    return Counter;
}

Here is the caller graph for this function:

Abc_NtkFaninFanoutCounters()

void Abc_NtkFaninFanoutCounters	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vFan,
		Vec_Int_t *	vFon,
		Vec_Int_t *	vFanR,
		Vec_Int_t *	vFonR )

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

Synopsis [Prints the distribution of fanins/fanouts in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 609 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i, nFanins, nFanouts;
    int nFaninsMax = 0, nFanoutsMax = 0;
    Abc_NtkForEachObj( pNtk, pNode, i )
    {
        nFaninsMax  = Abc_MaxInt( nFaninsMax,  Abc_ObjFaninNum(pNode) );
        nFanoutsMax = Abc_MaxInt( nFanoutsMax, Abc_ObjFanoutNum(pNode) );
    }
    Vec_IntFill( vFan, nFaninsMax + 1, 0 );
    Vec_IntFill( vFon, nFanoutsMax + 1, 0 );
    Vec_IntFill( vFanR, nFaninsMax + 1, 0 );
    Vec_IntFill( vFonR, nFanoutsMax + 1, 0 );
    Abc_NtkForEachObjReverse( pNtk, pNode, i )
    {
        nFanins  = Abc_ObjFaninNum( pNode );
        nFanouts = Abc_ObjFanoutNum( pNode );
        Vec_IntAddToEntry( vFan,  nFanins, 1 );
        Vec_IntAddToEntry( vFon, nFanouts, 1 );
        Vec_IntWriteEntry( vFanR, nFanins, i );
        Vec_IntWriteEntry( vFonR, nFanouts, i );
    }
}

Here is the caller graph for this function:

Abc_NtkGetArea()

float Abc_NtkGetArea

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Compute area using LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 210 of file abcPrint.c.

{
    If_LibLut_t * pLutLib;
    Abc_Obj_t * pObj;
    float Counter = 0.0;
    int i;
    assert( Abc_NtkIsLogic(pNtk) );
    // get the library
    pLutLib = (If_LibLut_t *)Abc_FrameReadLibLut();
    if ( pLutLib && pLutLib->LutMax >= Abc_NtkGetFaninMax(pNtk) )
    {
        Abc_NtkForEachNode( pNtk, pObj, i )
            Counter += pLutLib->pLutAreas[Abc_ObjFaninNum(pObj)];
    }
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkGetAreaSpecial()

float Abc_NtkGetAreaSpecial

(

Abc_Ntk_t *

pNtk

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 238 of file abcPrint.c.

{
    Abc_Obj_t * pObj; int i, Count = 0;    
    Abc_NtkForEachNode( pNtk, pObj, i )
        if ( !strncmp( Mio_GateReadName((Mio_Gate_t*)pObj->pData), "mm", 2 ) )
           Count++;
    return 1.0*Count/Abc_NtkNodeNum(pNtk);
}

Here is the call graph for this function:

Abc_NtkGetAreaSpecial2()

float Abc_NtkGetAreaSpecial2

(

Abc_Ntk_t *

pNtk

)

Definition at line 246 of file abcPrint.c.

{
    Abc_Obj_t * pObj; int i; 
    float Count = 0, CountAll = 0;    
    Abc_NtkForEachNode( pNtk, pObj, i ) {
        if ( !strncmp( Mio_GateReadName((Mio_Gate_t*)pObj->pData), "mm", 2 ) )
           Count += Mio_GateReadArea((Mio_Gate_t*)pObj->pData);
        CountAll += Mio_GateReadArea((Mio_Gate_t*)pObj->pData);
    }
    return 1.0*Count/CountAll;
}

Here is the call graph for this function:

Abc_NtkInOutConeCounters()

void Abc_NtkInOutConeCounters	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vFan,
		Vec_Int_t *	vFon,
		Vec_Int_t *	vFanR,
		Vec_Int_t *	vFonR )

Definition at line 811 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    Vec_Int_t * vSuppsCo = Abc_NtkCollectCoCones( pNtk, 1 );
    Vec_Int_t * vSuppsCi = Abc_NtkCollectCiCones( pNtk, 1 );
    int i, nFanins, nFanouts;
    int nFaninsMax  = Vec_IntFindMax( vSuppsCo );
    int nFanoutsMax = Vec_IntFindMax( vSuppsCi );
    Vec_IntFill( vFan, nFaninsMax + 1, 0 );
    Vec_IntFill( vFon, nFanoutsMax + 1, 0 );
    Vec_IntFill( vFanR, nFaninsMax + 1, 0 );
    Vec_IntFill( vFonR, nFanoutsMax + 1, 0 );
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        nFanins  = Vec_IntEntry( vSuppsCo, i );
        Vec_IntAddToEntry( vFan,  nFanins, 1 );
        Vec_IntWriteEntry( vFanR, nFanins, Abc_ObjId(pNode) );
    }
    Abc_NtkForEachCi( pNtk, pNode, i )
    {
        nFanouts = Vec_IntEntry( vSuppsCi, i );
        Vec_IntAddToEntry( vFon, nFanouts, 1 );
        Vec_IntWriteEntry( vFonR, nFanouts, Abc_ObjId(pNode) );
    }
    Vec_IntFree( vSuppsCo );
    Vec_IntFree( vSuppsCi );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkInOutSupportCounters()

void Abc_NtkInOutSupportCounters	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vFan,
		Vec_Int_t *	vFon,
		Vec_Int_t *	vFanR,
		Vec_Int_t *	vFonR )

Definition at line 725 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    Vec_Int_t * vSuppsCo = Abc_NtkCollectCoSupps( pNtk, 1 );
    Vec_Int_t * vSuppsCi = Abc_NtkCollectCiSupps( pNtk, 1 );
    int i, nFanins, nFanouts;
    int nFaninsMax  = Vec_IntFindMax( vSuppsCo );
    int nFanoutsMax = Vec_IntFindMax( vSuppsCi );
    Vec_IntFill( vFan, nFaninsMax + 1, 0 );
    Vec_IntFill( vFon, nFanoutsMax + 1, 0 );
    Vec_IntFill( vFanR, nFaninsMax + 1, 0 );
    Vec_IntFill( vFonR, nFanoutsMax + 1, 0 );
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        nFanins  = Vec_IntEntry( vSuppsCo, i );
        Vec_IntAddToEntry( vFan,  nFanins, 1 );
        Vec_IntWriteEntry( vFanR, nFanins, Abc_ObjId(pNode) );
    }
    Abc_NtkForEachCi( pNtk, pNode, i )
    {
        nFanouts = Vec_IntEntry( vSuppsCi, i );
        Vec_IntAddToEntry( vFon, nFanouts, 1 );
        Vec_IntWriteEntry( vFonR, nFanouts, Abc_ObjId(pNode) );
    }
    Vec_IntFree( vSuppsCo );
    Vec_IntFree( vSuppsCi );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkInputOutputCounters()

void Abc_NtkInputOutputCounters	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vFan,
		Vec_Int_t *	vFon,
		Vec_Int_t *	vFanR,
		Vec_Int_t *	vFonR )

Definition at line 633 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i, nFanins, nFanouts;
    int nFaninsMax = 0, nFanoutsMax = 0;
    Abc_NtkForEachCi( pNtk, pNode, i )
        nFanoutsMax = Abc_MaxInt( nFanoutsMax, Abc_ObjFanoutNum(pNode) );
    Abc_NtkForEachCo( pNtk, pNode, i )
        nFaninsMax  = Abc_MaxInt( nFaninsMax,  Abc_ObjFaninNum(Abc_ObjFanin0(pNode)) );
    Vec_IntFill( vFan, nFaninsMax + 1, 0 );
    Vec_IntFill( vFon, nFanoutsMax + 1, 0 );
    Vec_IntFill( vFanR, nFaninsMax + 1, 0 );
    Vec_IntFill( vFonR, nFanoutsMax + 1, 0 );
    Abc_NtkForEachCi( pNtk, pNode, i )
    {
        nFanouts = Abc_ObjFanoutNum( pNode );
        Vec_IntAddToEntry( vFon, nFanouts, 1 );
        Vec_IntWriteEntry( vFonR, nFanouts, Abc_ObjId(pNode) );
    }
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        nFanins  = Abc_ObjFaninNum( Abc_ObjFanin0(pNode) );
        Vec_IntAddToEntry( vFan,  nFanins, 1 );
        Vec_IntWriteEntry( vFanR, nFanins, Abc_ObjId(pNode) );
    }
}

Here is the caller graph for this function:

Abc_NtkMemory()

double Abc_NtkMemory

(

Abc_Ntk_t *

p

)

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

Synopsis [Collects memory usage.]

Description []

SideEffects []

SeeAlso []

Definition at line 135 of file abcPrint.c.

{
    Abc_Obj_t * pObj; int i;
    double Memory = sizeof(Abc_Ntk_t);
    Memory += sizeof(Abc_Obj_t) * Abc_NtkObjNum(p);
    Memory += Vec_PtrMemory(p->vPis);
    Memory += Vec_PtrMemory(p->vPos);
    Memory += Vec_PtrMemory(p->vCis);
    Memory += Vec_PtrMemory(p->vCos);
    Memory += Vec_PtrMemory(p->vObjs);
    Memory += Vec_IntMemory(&p->vTravIds);
    Memory += Vec_IntMemory(p->vLevelsR);
    Abc_NtkForEachObj( p, pObj, i )
        Memory += sizeof(int) * (Vec_IntCap(&pObj->vFanins) + Vec_IntCap(&pObj->vFanouts));
    return Memory;
}

Here is the caller graph for this function:

Abc_NtkMfsTotalGlitching()

float Abc_NtkMfsTotalGlitching	(	Abc_Ntk_t *	pNtk,
		int	nPats,
		int	Prob,
		int	fVerbose )

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

Synopsis [Returns the percentable of increased power due to glitching.]

Description []

SideEffects []

SeeAlso []

Definition at line 1942 of file abcPrint.c.

{
    int nSwitches, nGlitches;
    Gli_Man_t * p;
    Vec_Ptr_t * vNodes;
    Vec_Int_t * vFanins;
    Abc_Obj_t * pObj, * pFanin;
    int i, k, nFaninMax = Abc_NtkGetFaninMax(pNtk);
    if ( !Abc_NtkIsMappedLogic(pNtk) )
        return Abc_NtkMfsTotalGlitchingLut( pNtk, nPats, Prob, fVerbose );
    assert( Abc_NtkIsMappedLogic(pNtk) );
    if ( nFaninMax > 16 )
    {
        printf( "Abc_NtkMfsTotalGlitching() This procedure works only for mapped networks with LUTs size up to 6 inputs.\n" );
        return -1.0;
    }
    vNodes = Abc_NtkDfs( pNtk, 0 );
    vFanins = Vec_IntAlloc( 6 );
 
    // derive network for glitch computation
    p = Gli_ManAlloc( Vec_PtrSize(vNodes) + Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk),
        Abc_NtkLatchNum(pNtk), Abc_NtkGetTotalFanins(pNtk) + Abc_NtkCoNum(pNtk) );
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->iTemp = -1;
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->iTemp = Gli_ManCreateCi( p, Abc_ObjFanoutNum(pObj) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        Vec_IntClear( vFanins );
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Vec_IntPush( vFanins, pFanin->iTemp );
        pObj->iTemp = Gli_ManCreateNode( p, vFanins, Abc_ObjFanoutNum(pObj), Mio_GateReadTruthP((Mio_Gate_t *)pObj->pData) );
    }
    Abc_NtkForEachCo( pNtk, pObj, i )
        Gli_ManCreateCo( p, Abc_ObjFanin0(pObj)->iTemp );
 
    // compute glitching
    Gli_ManSwitchesAndGlitches( p, nPats, 1.0/Prob, fVerbose );
 
    // compute the ratio
    nSwitches = nGlitches = 0;
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( pObj->iTemp >= 0 )
        {
            nSwitches += Abc_ObjFanoutNum(pObj) * Gli_ObjNumSwitches(p, pObj->iTemp);
            nGlitches += Abc_ObjFanoutNum(pObj) * Gli_ObjNumGlitches(p, pObj->iTemp);
        }
 
    Gli_ManStop( p );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vFanins );
    return nSwitches ? 100.0*(nGlitches-nSwitches)/nSwitches : 0.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMfsTotalGlitchingLut()

float Abc_NtkMfsTotalGlitchingLut	(	Abc_Ntk_t *	pNtk,
		int	nPats,
		int	Prob,
		int	fVerbose )

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

Synopsis [Returns the percentable of increased power due to glitching.]

Description []

SideEffects []

SeeAlso []

Definition at line 1868 of file abcPrint.c.

{
    int nSwitches, nGlitches;
    Gli_Man_t * p;
    Vec_Ptr_t * vNodes;
    Vec_Int_t * vFanins, * vTruth;
    Abc_Obj_t * pObj, * pFanin;
    Vec_Wrd_t * vTruths; word * pTruth;
    unsigned * puTruth;
    int i, k;
    assert( Abc_NtkIsLogic(pNtk) );
    assert( Abc_NtkGetFaninMax(pNtk) <= 6 );
    if ( Abc_NtkGetFaninMax(pNtk) > 6 )
    {
        printf( "Abc_NtkMfsTotalGlitching() This procedure works only for mapped networks with LUTs size up to 6 inputs.\n" );
        return -1.0;
    }
    Abc_NtkToAig( pNtk );
    vNodes = Abc_NtkDfs( pNtk, 0 );
    vFanins = Vec_IntAlloc( 6 );
    vTruth = Vec_IntAlloc( 1 << 12 );
    vTruths = Vec_WrdStart( Abc_NtkObjNumMax(pNtk) );
 
    // derive network for glitch computation
    p = Gli_ManAlloc( Vec_PtrSize(vNodes) + Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk),
        Abc_NtkLatchNum(pNtk), Abc_NtkGetTotalFanins(pNtk) + Abc_NtkCoNum(pNtk) );
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->iTemp = -1;
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->iTemp = Gli_ManCreateCi( p, Abc_ObjFanoutNum(pObj) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        Vec_IntClear( vFanins );
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Vec_IntPush( vFanins, pFanin->iTemp );
        puTruth = Hop_ManConvertAigToTruth( (Hop_Man_t *)pNtk->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj), vTruth, 0 );
        pTruth = Vec_WrdEntryP( vTruths, Abc_ObjId(pObj) );
        *pTruth = ((word)puTruth[Abc_ObjFaninNum(pObj) == 6] << 32) | (word)puTruth[0];
        pObj->iTemp = Gli_ManCreateNode( p, vFanins, Abc_ObjFanoutNum(pObj), pTruth );
    }
    Abc_NtkForEachCo( pNtk, pObj, i )
        Gli_ManCreateCo( p, Abc_ObjFanin0(pObj)->iTemp );
 
    // compute glitching
    Gli_ManSwitchesAndGlitches( p, 4000, 1.0/8.0, 0 );
 
    // compute the ratio
    nSwitches = nGlitches = 0;
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( pObj->iTemp >= 0 )
        {
            nSwitches += Abc_ObjFanoutNum(pObj) * Gli_ObjNumSwitches(p, pObj->iTemp);
            nGlitches += Abc_ObjFanoutNum(pObj) * Gli_ObjNumGlitches(p, pObj->iTemp);
        }
 
    Gli_ManStop( p );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vTruth );
    Vec_IntFree( vFanins );
    Vec_WrdFree( vTruths );
    return nSwitches ? 100.0*(nGlitches-nSwitches)/nSwitches : 0.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMfsTotalSwitching()

float Abc_NtkMfsTotalSwitching

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Marks nodes for power-optimization.]

Description []

SideEffects []

SeeAlso []

Definition at line 163 of file abcPrint.c.

{
    extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters );
    extern Vec_Int_t * Saig_ManComputeSwitchProbs( Aig_Man_t * p, int nFrames, int nPref, int fProbOne );
    Vec_Int_t * vSwitching;
    float * pSwitching;
    Abc_Ntk_t * pNtkStr;
    Aig_Man_t * pAig;
    Aig_Obj_t * pObjAig;
    Abc_Obj_t * pObjAbc, * pObjAbc2;
    float Result = (float)0;
    int i;
    // strash the network
    pNtkStr = Abc_NtkStrash( pNtk, 0, 1, 0 );
    Abc_NtkForEachObj( pNtk, pObjAbc, i )
        if ( (pObjAbc->pTemp && Abc_ObjRegular((Abc_Obj_t *)pObjAbc->pTemp)->Type == ABC_FUNC_NONE) || (!Abc_ObjIsCi(pObjAbc) && !Abc_ObjIsNode(pObjAbc)) )
            pObjAbc->pTemp = NULL;
    // map network into an AIG
    pAig = Abc_NtkToDar( pNtkStr, 0, (int)(Abc_NtkLatchNum(pNtk) > 0) );
    vSwitching = Saig_ManComputeSwitchProbs( pAig, 48, 16, 0 );
    pSwitching = (float *)vSwitching->pArray;
    Abc_NtkForEachObj( pNtk, pObjAbc, i )
    {
        if ( (pObjAbc2 = Abc_ObjRegular((Abc_Obj_t *)pObjAbc->pTemp)) && (pObjAig = Aig_Regular((Aig_Obj_t *)pObjAbc2->pTemp)) )
        {
            Result += Abc_ObjFanoutNum(pObjAbc) * pSwitching[pObjAig->Id];
//            Abc_ObjPrint( stdout, pObjAbc );
//            printf( "%d = %.2f\n", i, Abc_ObjFanoutNum(pObjAbc) * pSwitching[pObjAig->Id] );
        }
    }
    Vec_IntFree( vSwitching );
    Aig_ManStop( pAig );
    Abc_NtkDelete( pNtkStr );
    return Result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkPrintDistribInternal()

void Abc_NtkPrintDistribInternal	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		char *	pFanins,
		char *	pFanouts,
		char *	pNode,
		char *	pFanin,
		char *	pFanout,
		Vec_Int_t *	vFan,
		Vec_Int_t *	vFon,
		Vec_Int_t *	vFanR,
		Vec_Int_t *	vFonR )

Definition at line 839 of file abcPrint.c.

{
    int k, nSizeMax = Abc_MaxInt( Vec_IntSize(vFan), Vec_IntSize(vFon) );
    fprintf( pFile, "The distribution of %s and %s in the network:\n", pFanins, pFanouts );
    fprintf( pFile, "  Number   %s with %s  %s with %s          Repr1             Repr2\n", pNode, pFanin, pNode, pFanout );
    for ( k = 0; k < nSizeMax; k++ )
    {
        int EntryFan = k < Vec_IntSize(vFan) ? Vec_IntEntry(vFan, k) : 0;
        int EntryFon = k < Vec_IntSize(vFon) ? Vec_IntEntry(vFon, k) : 0;
        if ( EntryFan == 0 && EntryFon == 0 )
            continue;
 
        fprintf( pFile, "%5d : ", k );
        if ( EntryFan == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12d  ", EntryFan );
        fprintf( pFile, "    " );
        if ( EntryFon == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12d  ", EntryFon );
 
        fprintf( pFile, "        " );
        if ( EntryFan == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12s  ", Abc_ObjName(Abc_NtkObj(pNtk, Vec_IntEntry(vFanR, k))) );
        fprintf( pFile, "    " );
        if ( EntryFon == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12s  ", Abc_ObjName(Abc_NtkObj(pNtk, Vec_IntEntry(vFonR, k))) );
        fprintf( pFile, "\n" );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkPrintFactor()

void Abc_NtkPrintFactor	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fUseRealNames )

Definition at line 1129 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsSopLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
        Abc_NodePrintFactor( pFile, pNode, fUseRealNames );
}

Here is the call graph for this function:

Abc_NtkPrintFanio()

void Abc_NtkPrintFanio	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fUseFanio,
		int	fUsePio,
		int	fUseSupp,
		int	fUseCone )

Definition at line 876 of file abcPrint.c.

{
    Vec_Int_t * vFan = Vec_IntAlloc( 0 );
    Vec_Int_t * vFon = Vec_IntAlloc( 0 );
    Vec_Int_t * vFanR = Vec_IntAlloc( 0 );
    Vec_Int_t * vFonR = Vec_IntAlloc( 0 );
    assert( fUseFanio + fUsePio + fUseSupp + fUseCone == 1 );
    if ( fUseFanio )
    {
        Abc_NtkFaninFanoutCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "fanins", "fanouts", "Nodes", "fanin", "fanout", vFan, vFon, vFanR, vFonR ); 
    }
    else if ( fUsePio )
    {
        Abc_NtkInputOutputCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "fanins", "fanouts", "I/O", "fanin", "fanout", vFan, vFon, vFanR, vFonR ); 
    }
    else if ( fUseSupp )
    {
        Abc_NtkInOutSupportCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "input supports", "output supports", "I/O", "in-supp", "out-supp", vFan, vFon, vFanR, vFonR ); 
    }
    else if ( fUseCone )
    {
        Abc_NtkInOutConeCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "input cones", "output cones", "I/O", "in-cone", "out-cone", vFan, vFon, vFanR, vFonR ); 
    }
    Vec_IntFree( vFan );
    Vec_IntFree( vFon );
    Vec_IntFree( vFanR );
    Vec_IntFree( vFonR );
}

Here is the call graph for this function:

Abc_NtkPrintFanioNew()

void Abc_NtkPrintFanioNew	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fMffc )

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

Synopsis [Prints the distribution of fanins/fanouts in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 921 of file abcPrint.c.

{
    char Buffer[100];
    Abc_Obj_t * pNode;
    Vec_Int_t * vFanins, * vFanouts;
    int nFanins, nFanouts, nFaninsMax, nFanoutsMax, nFaninsAll, nFanoutsAll;
    int i, k, nSizeMax;
 
    // determine the largest fanin and fanout
    nFaninsMax = nFanoutsMax = 0;
    nFaninsAll = nFanoutsAll = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( fMffc && Abc_ObjFanoutNum(pNode) == 1 )
            continue;
        nFanins  = Abc_ObjFaninNum(pNode);
        if ( Abc_NtkIsNetlist(pNtk) )
            nFanouts = Abc_ObjFanoutNum( Abc_ObjFanout0(pNode) );
        else if ( fMffc )
            nFanouts = Abc_NodeMffcSize(pNode);
        else
            nFanouts = Abc_ObjFanoutNum(pNode);
        nFaninsAll  += nFanins;
        nFanoutsAll += nFanouts;
        nFaninsMax   = Abc_MaxInt( nFaninsMax, nFanins );
        nFanoutsMax  = Abc_MaxInt( nFanoutsMax, nFanouts );
    }
 
    // allocate storage for fanin/fanout numbers
    nSizeMax = Abc_MaxInt( 10 * (Abc_Base10Log(nFaninsMax) + 1), 10 * (Abc_Base10Log(nFanoutsMax) + 1) );
    vFanins  = Vec_IntStart( nSizeMax );
    vFanouts = Vec_IntStart( nSizeMax );
 
    // count the number of fanins and fanouts
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( fMffc && Abc_ObjFanoutNum(pNode) == 1 )
            continue;
        nFanins  = Abc_ObjFaninNum(pNode);
        if ( Abc_NtkIsNetlist(pNtk) )
            nFanouts = Abc_ObjFanoutNum( Abc_ObjFanout0(pNode) );
        else if ( fMffc )
            nFanouts = Abc_NodeMffcSize(pNode);
        else
            nFanouts = Abc_ObjFanoutNum(pNode);
 
        if ( nFanins < 10 )
            Vec_IntAddToEntry( vFanins, nFanins, 1 );
        else if ( nFanins < 100 )
            Vec_IntAddToEntry( vFanins, 10 + nFanins/10, 1 );
        else if ( nFanins < 1000 )
            Vec_IntAddToEntry( vFanins, 20 + nFanins/100, 1 );
        else if ( nFanins < 10000 )
            Vec_IntAddToEntry( vFanins, 30 + nFanins/1000, 1 );
        else if ( nFanins < 100000 )
            Vec_IntAddToEntry( vFanins, 40 + nFanins/10000, 1 );
        else if ( nFanins < 1000000 )
            Vec_IntAddToEntry( vFanins, 50 + nFanins/100000, 1 );
        else if ( nFanins < 10000000 )
            Vec_IntAddToEntry( vFanins, 60 + nFanins/1000000, 1 );
 
        if ( nFanouts < 10 )
            Vec_IntAddToEntry( vFanouts, nFanouts, 1 );
        else if ( nFanouts < 100 )
            Vec_IntAddToEntry( vFanouts, 10 + nFanouts/10, 1 );
        else if ( nFanouts < 1000 )
            Vec_IntAddToEntry( vFanouts, 20 + nFanouts/100, 1 );
        else if ( nFanouts < 10000 )
            Vec_IntAddToEntry( vFanouts, 30 + nFanouts/1000, 1 );
        else if ( nFanouts < 100000 )
            Vec_IntAddToEntry( vFanouts, 40 + nFanouts/10000, 1 );
        else if ( nFanouts < 1000000 )
            Vec_IntAddToEntry( vFanouts, 50 + nFanouts/100000, 1 );
        else if ( nFanouts < 10000000 )
            Vec_IntAddToEntry( vFanouts, 60 + nFanouts/1000000, 1 );
    }
 
    fprintf( pFile, "The distribution of fanins and fanouts in the network:\n" );
    fprintf( pFile, "         Number   Nodes with fanin  Nodes with fanout\n" );
    for ( k = 0; k < nSizeMax; k++ )
    {
        if ( vFanins->pArray[k] == 0 && vFanouts->pArray[k] == 0 )
            continue;
        if ( k < 10 )
            fprintf( pFile, "%15d : ", k );
        else
        {
            sprintf( Buffer, "%d - %d", (int)pow((double)10, k/10) * (k%10), (int)pow((double)10, k/10) * (k%10+1) - 1 );
            fprintf( pFile, "%15s : ", Buffer );
        }
        if ( vFanins->pArray[k] == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12d  ", vFanins->pArray[k] );
        fprintf( pFile, "    " );
        if ( vFanouts->pArray[k] == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12d  ", vFanouts->pArray[k] );
        fprintf( pFile, "\n" );
    }
    Vec_IntFree( vFanins );
    Vec_IntFree( vFanouts );
 
    fprintf( pFile, "Fanins: Max = %d. Ave = %.2f.  Fanouts: Max = %d. Ave =  %.2f.\n",
        nFaninsMax,  1.0*nFaninsAll/Abc_NtkNodeNum(pNtk),
        nFanoutsMax, 1.0*nFanoutsAll/Abc_NtkNodeNum(pNtk)  );
/*
    Abc_NtkForEachCi( pNtk, pNode, i )
    {
        printf( "%d ", Abc_ObjFanoutNum(pNode) );
    }
    printf( "\n" );
*/
}

Here is the call graph for this function:

Abc_NtkPrintGates()

void Abc_NtkPrintGates	(	Abc_Ntk_t *	pNtk,
		int	fUseLibrary,
		int	fUpdateProfile )

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

Synopsis [Prints statistics about gates used in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 1429 of file abcPrint.c.

{
    Abc_Obj_t * pObj;
    int fHasBdds, i;
    int CountConst, CountBuf, CountInv, CountAnd, CountOr, CountOther, CounterTotal, TotalDiff = 0;
    char * pSop;
 
    if ( fUseLibrary && Abc_NtkHasMapping(pNtk) )
    {
        Mio_Gate_t ** ppGates;
        double Area, AreaTotal;
        int Counter, nGates, i, nGateNameLen;
 
        // clean value of all gates
        nGates = Mio_LibraryReadGateNum( (Mio_Library_t *)pNtk->pManFunc );
        ppGates = Mio_LibraryReadGateArray( (Mio_Library_t *)pNtk->pManFunc );
        for ( i = 0; i < nGates; i++ )
        {
            Mio_GateSetValue( ppGates[i], 0 );
            if ( fUpdateProfile )
                Mio_GateSetProfile2( ppGates[i], 0 );
        }
 
        // count the gates by name
        CounterTotal = 0;
        Abc_NtkForEachNodeNotBarBuf( pNtk, pObj, i )
        {
            if ( i == 0 ) continue;
            Mio_GateSetValue( (Mio_Gate_t *)pObj->pData, 1 + Mio_GateReadValue((Mio_Gate_t *)pObj->pData) );
            if ( fUpdateProfile )
                Mio_GateIncProfile2( (Mio_Gate_t *)pObj->pData );
            CounterTotal++;
            // assuming that twin gates follow each other
            if ( Abc_NtkFetchTwinNode(pObj) )
                i++;
        }
 
        // determine the longest gate name
        nGateNameLen = 5;
        for ( i = 0; i < nGates; i++ )
        {
            Counter = Mio_GateReadValue( ppGates[i] );
            if ( Counter == 0 )
                continue;
            nGateNameLen = Abc_MaxInt( nGateNameLen, strlen(Mio_GateReadName(ppGates[i])) );
        }
 
        // print the gates
        AreaTotal = Abc_NtkGetMappedArea(pNtk);
        for ( i = 0; i < nGates; i++ )
        {
            Counter = Mio_GateReadValue( ppGates[i] );
            if ( Counter == 0 && Mio_GateReadProfile(ppGates[i]) == 0 )
                continue;
            if ( Mio_GateReadPinNum(ppGates[i]) > 1 )
                TotalDiff += Abc_AbsInt( Mio_GateReadProfile(ppGates[i]) - Mio_GateReadProfile2(ppGates[i]) );
            Area = Counter * Mio_GateReadArea( ppGates[i] );
            printf( "%-*s   Fanin = %2d   Instance = %8d   Area = %10.2f   %6.2f %%   %8d  %8d   %s\n",
                nGateNameLen, Mio_GateReadName( ppGates[i] ),
                Mio_GateReadPinNum( ppGates[i] ),
                Counter, Area, 100.0 * Area / AreaTotal,
                Mio_GateReadProfile(ppGates[i]),
                Mio_GateReadProfile2(ppGates[i]),
                Mio_GateReadForm(ppGates[i]) );
        }
        printf( "%-*s                Instance = %8d   Area = %10.2f   %6.2f %%   AbsDiff = %d\n",
            nGateNameLen, "TOTAL",
            CounterTotal, AreaTotal, 100.0, TotalDiff );
        return;
    }
 
    if ( Abc_NtkIsAigLogic(pNtk) )
        return;
 
    // transform logic functions from BDD to SOP
    if ( (fHasBdds = Abc_NtkIsBddLogic(pNtk)) )
    {
        if ( !Abc_NtkBddToSop(pNtk, -1, ABC_INFINITY, 1) )
        {
            printf( "Abc_NtkPrintGates(): Converting to SOPs has failed.\n" );
            return;
        }
    }
 
    // get hold of the SOP of the node
    CountConst = CountBuf = CountInv = CountAnd = CountOr = CountOther = CounterTotal = 0;
    Abc_NtkForEachNodeNotBarBuf( pNtk, pObj, i )
    {
        if ( i == 0 ) continue;
        if ( Abc_NtkHasMapping(pNtk) )
            pSop = Mio_GateReadSop((Mio_Gate_t *)pObj->pData);
        else
            pSop = (char *)pObj->pData;
        // collect the stats
        if ( Abc_SopIsConst0(pSop) || Abc_SopIsConst1(pSop) )
            CountConst++;
        else if ( Abc_SopIsBuf(pSop) )
            CountBuf++;
        else if ( Abc_SopIsInv(pSop) )
            CountInv++;
        else if ( (!Abc_SopIsComplement(pSop) && Abc_SopIsAndType(pSop)) ||
                  ( Abc_SopIsComplement(pSop) && Abc_SopIsOrType(pSop)) )
            CountAnd++;
        else if ( ( Abc_SopIsComplement(pSop) && Abc_SopIsAndType(pSop)) ||
                  (!Abc_SopIsComplement(pSop) && Abc_SopIsOrType(pSop)) )
            CountOr++;
        else
            CountOther++;
        CounterTotal++;
    }
    printf( "Const        = %8d    %6.2f %%\n", CountConst  ,  100.0 * CountConst   / CounterTotal );
    printf( "Buffer       = %8d    %6.2f %%\n", CountBuf    ,  100.0 * CountBuf     / CounterTotal );
    printf( "Inverter     = %8d    %6.2f %%\n", CountInv    ,  100.0 * CountInv     / CounterTotal );
    printf( "And          = %8d    %6.2f %%\n", CountAnd    ,  100.0 * CountAnd     / CounterTotal );
    printf( "Or           = %8d    %6.2f %%\n", CountOr     ,  100.0 * CountOr      / CounterTotal );
    printf( "Other        = %8d    %6.2f %%\n", CountOther  ,  100.0 * CountOther   / CounterTotal );
    printf( "TOTAL        = %8d    %6.2f %%\n", CounterTotal,  100.0 * CounterTotal / CounterTotal );
 
    // convert the network back into BDDs if this is how it was
    if ( fHasBdds )
        Abc_NtkSopToBdd(pNtk);
}

Here is the call graph for this function:

Abc_NtkPrintIo()

void Abc_NtkPrintIo	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fPrintFlops )

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

Synopsis [Prints PIs/POs and LIs/LOs.]

Description []

SideEffects []

SeeAlso []

Definition at line 499 of file abcPrint.c.

{
    Abc_Obj_t * pObj;
    int i;
 
    fprintf( pFile, "Primary inputs (%d): ", Abc_NtkPiNum(pNtk) );
    Abc_NtkForEachPi( pNtk, pObj, i )
        fprintf( pFile, " %d=%s", i, Abc_ObjName(pObj) );
//        fprintf( pFile, " %s(%d)", Abc_ObjName(pObj), Abc_ObjFanoutNum(pObj) );
    fprintf( pFile, "\n" );
 
    fprintf( pFile, "Primary outputs (%d):", Abc_NtkPoNum(pNtk) );
    Abc_NtkForEachPo( pNtk, pObj, i )
        fprintf( pFile, " %d=%s", i, Abc_ObjName(pObj) );
    fprintf( pFile, "\n" );
 
    if ( !fPrintFlops )
        return;
 
    fprintf( pFile, "Latches (%d):  ", Abc_NtkLatchNum(pNtk) );
    Abc_NtkForEachLatch( pNtk, pObj, i )
        fprintf( pFile, " %s(%s=%s)", Abc_ObjName(pObj),
            Abc_ObjName(Abc_ObjFanout0(pObj)), Abc_ObjName(Abc_ObjFanin0(pObj)) );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Abc_NtkPrintLatch()

void Abc_NtkPrintLatch	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk )

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

Synopsis [Prints statistics about latches.]

Description []

SideEffects []

SeeAlso []

Definition at line 536 of file abcPrint.c.

{
    Abc_Obj_t * pLatch, * pFanin;
    int i, Counter0, Counter1, Counter2;
    int InitNums[4], Init;
 
    assert( !Abc_NtkIsNetlist(pNtk) );
    if ( Abc_NtkLatchNum(pNtk) == 0 )
    {
        fprintf( pFile, "The network is combinational.\n" );
        return;
    }
 
    for ( i = 0; i < 4; i++ )
        InitNums[i] = 0;
    Counter0 = Counter1 = Counter2 = 0;
    Abc_NtkForEachLatch( pNtk, pLatch, i )
    {
        Init = Abc_LatchInit( pLatch );
        assert( Init < 4 );
        InitNums[Init]++;
 
        pFanin = Abc_ObjFanin0(Abc_ObjFanin0(pLatch));
        if ( Abc_NtkIsLogic(pNtk) )
        {
            if ( !Abc_NodeIsConst(pFanin) )
                continue;
        }
        else if ( Abc_NtkIsStrash(pNtk) )
        {
            if ( !Abc_AigNodeIsConst(pFanin) )
                continue;
        }
        else
            assert( 0 );
 
        // the latch input is a constant node
        Counter0++;
        if ( Abc_LatchIsInitDc(pLatch) )
        {
            Counter1++;
            continue;
        }
        // count the number of cases when the constant is equal to the initial value
        if ( Abc_NtkIsStrash(pNtk) )
        {
            if ( Abc_LatchIsInit1(pLatch) == !Abc_ObjFaninC0(pLatch) )
                Counter2++;
        }
        else
        {
            if ( Abc_LatchIsInit1(pLatch) == Abc_NodeIsConst1(Abc_ObjFanin0(Abc_ObjFanin0(pLatch))) )
                Counter2++;
        }
    }
//    fprintf( pFile, "%-15s:  ", pNtk->pName );
    fprintf( pFile, "Total latches = %5d. Init0 = %d. Init1 = %d. InitDC = %d. Const data = %d.\n",
        Abc_NtkLatchNum(pNtk), InitNums[1], InitNums[2], InitNums[3], Counter0 );
//    fprintf( pFile, "Const fanin = %3d. DC init = %3d. Matching init = %3d. ", Counter0, Counter1, Counter2 );
//    fprintf( pFile, "Self-feed latches = %2d.\n", -1 ); //Abc_NtkCountSelfFeedLatches(pNtk) );
}

Here is the call graph for this function:

Abc_NtkPrintLevel()

void Abc_NtkPrintLevel	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fProfile,
		int	fListNodes,
		int	fOutputs,
		int	fVerbose )

Definition at line 1231 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i, k, Length;
    if ( fOutputs )
    {
        Abc_NtkLevel(pNtk);
        printf( "Outputs by level: " );
        Abc_NtkForEachCo( pNtk, pNode, k )
            printf( "%d=%d ", k, Abc_ObjFanin0(pNode)->Level );
        printf( "\n" );
        return;        
    }
    if ( fListNodes )
    {
        int nLevels;
        nLevels = Abc_NtkLevel(pNtk);
        printf( "Nodes by level:\n" );
        for ( i = 0; i <= nLevels; i++ )
        {
            printf( "%2d : ", i );
            Abc_NtkForEachNode( pNtk, pNode, k )
                if ( (int)pNode->Level == i )
                    printf( " %s", Abc_NodeGetPrintName(pNode) );
            printf( "\n" );
        }
        return;
    }
 
    // print the delay profile
    if ( fProfile && Abc_NtkHasMapping(pNtk) )
    {
        int nIntervals = 12;
        float DelayMax, DelayCur, DelayDelta;
        int * pLevelCounts;
        int DelayInt, nOutsSum, nOutsTotal;
 
        // get the max delay and delta
        DelayMax   = Abc_NtkDelayTrace( pNtk, NULL, NULL, 0 );
        DelayDelta = DelayMax/nIntervals;
        // collect outputs by delay
        pLevelCounts = ABC_ALLOC( int, nIntervals );
        memset( pLevelCounts, 0, sizeof(int) * nIntervals );
        Abc_NtkForEachCo( pNtk, pNode, i )
        {
            if ( Abc_ObjIsNode(Abc_ObjFanin0(pNode)) && Abc_ObjFaninNum(Abc_ObjFanin0(pNode)) == 0 )
                DelayInt = 0;
            else
            {
                DelayCur  = Abc_NodeReadArrivalWorst( Abc_ObjFanin0(pNode) );
                DelayInt  = (int)(DelayCur / DelayDelta);
                if ( DelayInt >= nIntervals )
                    DelayInt = nIntervals - 1;
            }
            pLevelCounts[DelayInt]++;
        }
 
        nOutsSum   = 0;
        nOutsTotal = Abc_NtkCoNum(pNtk);
        for ( i = 0; i < nIntervals; i++ )
        {
            nOutsSum += pLevelCounts[i];
            printf( "[%8.2f - %8.2f] :   COs = %4d.   %5.1f %%\n",
                DelayDelta * i, DelayDelta * (i+1), pLevelCounts[i], 100.0 * nOutsSum/nOutsTotal );
        }
        ABC_FREE( pLevelCounts );
        return;
    }
    else if ( fProfile )
    {
        int LevelMax, * pLevelCounts;
        int nOutsSum, nOutsTotal;
 
        if ( !Abc_NtkIsStrash(pNtk) )
            Abc_NtkLevel(pNtk);
 
        LevelMax = 0;
        Abc_NtkForEachCo( pNtk, pNode, i )
            if ( LevelMax < (int)Abc_ObjFanin0(pNode)->Level )
                LevelMax = Abc_ObjFanin0(pNode)->Level;
        pLevelCounts = ABC_ALLOC( int, LevelMax + 1 );
        memset( pLevelCounts, 0, sizeof(int) * (LevelMax + 1) );
        Abc_NtkForEachCo( pNtk, pNode, i )
            pLevelCounts[Abc_ObjFanin0(pNode)->Level]++;
 
        nOutsSum   = 0;
        nOutsTotal = Abc_NtkCoNum(pNtk);
        for ( i = 0; i <= LevelMax; i++ )
            if ( pLevelCounts[i] )
            {
                nOutsSum += pLevelCounts[i];
                printf( "Level = %4d.  COs = %4d.   %5.1f %%\n", i, pLevelCounts[i], 100.0 * nOutsSum/nOutsTotal );
            }
        ABC_FREE( pLevelCounts );
        return;
    }
    assert( Abc_NtkIsStrash(pNtk) );
 
    if ( fVerbose )
    {
        // find the longest name
        Length = 0;
        Abc_NtkForEachCo( pNtk, pNode, i )
            if ( Length < (int)strlen(Abc_ObjName(pNode)) )
                Length = strlen(Abc_ObjName(pNode));
        if ( Length < 5 )
            Length = 5;
        // print stats for each output
        Abc_NtkForEachCo( pNtk, pNode, i )
        {
            fprintf( pFile, "CO %4d :  %*s    ", i, Length, Abc_ObjName(pNode) );
            Abc_NodePrintLevel( pFile, pNode );
    }
    }
}

Here is the call graph for this function:

Abc_NtkPrintMffc()

void Abc_NtkPrintMffc	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk )

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

Synopsis [Prints the MFFCs of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1080 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i;
    extern void Abc_NodeMffcConeSuppPrint( Abc_Obj_t * pNode );
    Abc_NtkForEachNode( pNtk, pNode, i )
        if ( Abc_ObjFanoutNum(pNode) > 1 || (Abc_ObjFanoutNum(pNode) == 1 && Abc_ObjIsCo(Abc_ObjFanout0(pNode))))
            Abc_NodeMffcConeSuppPrint( pNode );
}

Here is the call graph for this function:

Abc_NtkPrintMiter()

void Abc_NtkPrintMiter

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Checks the status of the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 1750 of file abcPrint.c.

{
    Abc_Obj_t * pObj, * pChild, * pConst1 = Abc_AigConst1(pNtk);
    int i, iOut = -1;
    abctime Time = Abc_Clock();
    int nUnsat = 0;
    int nSat   = 0;
    int nUndec = 0;
    int nPis   = 0;
    Abc_NtkForEachPi( pNtk, pObj, i )
        nPis += (int)( Abc_ObjFanoutNum(pObj) > 0 );
    Abc_NtkForEachPo( pNtk, pObj, i )
    {
        pChild = Abc_ObjChild0(pObj);
        // check if the output is constant 0
        if ( pChild == Abc_ObjNot(pConst1) )
            nUnsat++;
        // check if the output is constant 1
        else if ( pChild == pConst1 )
        {
            nSat++;
            if ( iOut == -1 )
                iOut = i;
        }
        // check if the output is a primary input
        else if ( Abc_ObjIsPi(Abc_ObjRegular(pChild)) )
        {
            nSat++;
            if ( iOut == -1 )
                iOut = i;
        }
    // check if the output is 1 for the 0000 pattern
        else if ( Abc_ObjRegular(pChild)->fPhase != (unsigned)Abc_ObjIsComplement(pChild) )
        {
            nSat++;
            if ( iOut == -1 )
                iOut = i;
        }
        else
            nUndec++;
    }
    printf( "Miter:  I =%6d", nPis );
    printf( "  N =%7d", Abc_NtkNodeNum(pNtk) );
    printf( "  ? =%7d", nUndec );
    printf( "  U =%6d", nUnsat );
    printf( "  S =%6d", nSat );
    Time = Abc_Clock() - Time;
    printf(" %7.2f sec\n", (float)(Time)/(float)(CLOCKS_PER_SEC));
    if ( iOut >= 0 )
        printf( "The first satisfiable output is number %d (%s).\n", iOut, Abc_ObjName( Abc_NtkPo(pNtk, iOut) ) );
}

Here is the call graph for this function:

Abc_NtkPrintPoEquivs()

void Abc_NtkPrintPoEquivs

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Checks the status of the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 1813 of file abcPrint.c.

{
    Abc_Obj_t * pObj, * pDriver, * pRepr;  int i, iRepr;
    Vec_Int_t * vMap = Vec_IntStartFull( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachPo( pNtk, pObj, i )
    {
        pDriver = Abc_ObjFanin0(pObj);
        if ( Abc_NtkIsStrash(pNtk) && pDriver == Abc_AigConst1(pNtk) )
        {
            printf( "%s = Const%d\n", Abc_ObjName(pObj), !Abc_ObjFaninC0(pObj) );
            continue;
        }
        else if ( !Abc_NtkIsStrash(pNtk) && Abc_NodeIsConst(pDriver) )
        {
            printf( "%s = Const%d\n", Abc_ObjName(pObj), Abc_NodeIsConst1(pDriver) );
            continue;
        }
        iRepr = Vec_IntEntry( vMap, Abc_ObjId(pDriver) );
        if ( iRepr == -1 )
        {
            Vec_IntWriteEntry( vMap, Abc_ObjId(pDriver), i );
            continue;
        }
        pRepr = Abc_NtkCo(pNtk, iRepr);
        printf( "%s = %s%s\n", Abc_ObjName(pObj), Abc_ObjFaninC0(pRepr) == Abc_ObjFaninC0(pObj) ? "" : "!", Abc_ObjName(pRepr) );
    }
    Vec_IntFree( vMap );
}

Here is the call graph for this function:

Abc_NtkPrintSharing()

void Abc_NtkPrintSharing

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Prints statistics about gates used in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 1563 of file abcPrint.c.

{
    Vec_Ptr_t * vNodes1, * vNodes2;
    Abc_Obj_t * pObj1, * pObj2, * pNode1, * pNode2;
    int i, k, m, n, Counter;
 
    // print the template
    printf( "Statistics about sharing of logic nodes among the CO pairs.\n" );
    printf( "(CO1,CO2)=NumShared : " );
    // go though the CO pairs
    Abc_NtkForEachCo( pNtk, pObj1, i )
    {
        vNodes1 = Abc_NtkDfsNodes( pNtk, &pObj1, 1 );
        // mark the nodes
        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes1, pNode1, m )
            pNode1->fMarkA = 1;
        // go through the second COs
        Abc_NtkForEachCo( pNtk, pObj2, k )
        {
            if ( i >= k )
                continue;
            vNodes2 = Abc_NtkDfsNodes( pNtk, &pObj2, 1 );
            // count the number of marked
            Counter = 0;
            Vec_PtrForEachEntry( Abc_Obj_t *, vNodes2, pNode2, n )
                Counter += pNode2->fMarkA;
            // print
            printf( "(%d,%d)=%d ", i, k, Counter );
            Vec_PtrFree( vNodes2 );
        }
        // unmark the nodes
        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes1, pNode1, m )
            pNode1->fMarkA = 0;
        Vec_PtrFree( vNodes1 );
    }
    printf( "\n" );
}

Here is the call graph for this function:

Abc_NtkPrintSop()

void Abc_NtkPrintSop	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fUseRealNames )

Definition at line 1200 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsSopLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
        Abc_NodePrintSop( pFile, pNode, fUseRealNames );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkPrintStats()

void Abc_NtkPrintStats	(	Abc_Ntk_t *	pNtk,
		int	fFactored,
		int	fSaveBest,
		int	fDumpResult,
		int	fUseLutLib,
		int	fPrintMuxes,
		int	fPower,
		int	fGlitch,
		int	fSkipBuf,
		int	fSkipSmall,
		int	fPrintMem )

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

Synopsis [Print the vital stats of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 269 of file abcPrint.c.

{
    int nSingles = fSkipBuf ? Abc_NtkGetBufNum(pNtk) : 0;
    if ( fPrintMuxes && Abc_NtkIsStrash(pNtk) )
    {
        extern int Abc_NtkCountMuxes( Abc_Ntk_t * pNtk );
        int nXors = Abc_NtkGetExorNum(pNtk);
        int nMuxs = Abc_NtkCountMuxes(pNtk) - nXors;
        int nAnds = Abc_NtkNodeNum(pNtk) - (nMuxs + nXors) * 3 - nSingles;
        Abc_Print( 1, "XMA stats:  " );
        Abc_Print( 1,"Xor =%7d (%6.2f %%)  ", nXors, 300.0 * nXors / Abc_NtkNodeNum(pNtk) );
        Abc_Print( 1,"Mux =%7d (%6.2f %%)  ", nMuxs, 300.0 * nMuxs / Abc_NtkNodeNum(pNtk) );
        Abc_Print( 1,"And =%7d (%6.2f %%)  ",   nAnds, 100.0 * nAnds / Abc_NtkNodeNum(pNtk) );
        Abc_Print( 1,"Total =%7d",   nAnds + nXors + nMuxs );
        Abc_Print( 1,"\n" );
        return;
    }
    if ( fSaveBest )
        Abc_NtkCompareAndSaveBest( pNtk );
/*
    if ( fDumpResult )
    {
        char Buffer[1000] = {0};
        const char * pNameGen = pNtk->pSpec? Extra_FileNameGeneric( pNtk->pSpec ) : "nameless_";
        sprintf( Buffer, "%s_dump.blif", pNameGen );
        Io_Write( pNtk, Buffer, IO_FILE_BLIF );
        if ( pNtk->pSpec ) ABC_FREE( pNameGen );
    }
*/
 
//    if ( Abc_NtkIsStrash(pNtk) )
//        Abc_AigCountNext( pNtk->pManFunc );
 
#ifdef WIN32
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 15 ); // bright
    Abc_Print( 1,"%-30s:", pNtk->pName );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
#else
    Abc_Print( 1,"%s%-30s:%s", "\033[1;37m", pNtk->pName, "\033[0m" );  // bright
#endif
    Abc_Print( 1," i/o =%5d/%5d", Abc_NtkPiNum(pNtk), Abc_NtkPoNum(pNtk) );
    if ( Abc_NtkConstrNum(pNtk) )
        Abc_Print( 1,"(c=%d)", Abc_NtkConstrNum(pNtk) );
    Abc_Print( 1,"  lat =%5d", Abc_NtkLatchNum(pNtk) );
    if ( pNtk->nBarBufs )
        Abc_Print( 1,"(b=%d)", pNtk->nBarBufs );
    if ( Abc_NtkIsNetlist(pNtk) )
    {
        Abc_Print( 1,"  net =%5d", Abc_NtkNetNum(pNtk) );
        Abc_Print( 1,"  nd =%5d",  fSkipSmall ? Abc_NtkGetLargeNodeNum(pNtk) : Abc_NtkNodeNum(pNtk) - nSingles );
        Abc_Print( 1,"  wbox =%3d", Abc_NtkWhiteboxNum(pNtk) );
        Abc_Print( 1,"  bbox =%3d", Abc_NtkBlackboxNum(pNtk) );
    }
    else if ( Abc_NtkIsStrash(pNtk) )
    {
        Abc_Print( 1,"  and =%7d", Abc_NtkNodeNum(pNtk) );
        if ( Abc_NtkGetChoiceNum(pNtk) )
            Abc_Print( 1," (choice = %d)", Abc_NtkGetChoiceNum(pNtk) );
    }
    else
    {
        Abc_Print( 1,"  nd =%6d", fSkipSmall ? Abc_NtkGetLargeNodeNum(pNtk) : Abc_NtkNodeNum(pNtk) - nSingles );
        Abc_Print( 1,"  edge =%7d", Abc_NtkGetTotalFanins(pNtk) - nSingles );
    }
 
    if ( Abc_NtkIsStrash(pNtk) || Abc_NtkIsNetlist(pNtk) )
    {
    }
    else if ( Abc_NtkHasSop(pNtk) )
    {
 
        Abc_Print( 1,"  cube =%6d",  Abc_NtkGetCubeNum(pNtk) - nSingles );
        if ( fFactored )
            Abc_Print( 1,"  lit(sop) =%6d",  Abc_NtkGetLitNum(pNtk) - nSingles );
        if ( fFactored )
            Abc_Print( 1,"  lit(fac) =%6d",  Abc_NtkGetLitFactNum(pNtk) - nSingles );
    }
    else if ( Abc_NtkHasAig(pNtk) )
        Abc_Print( 1,"  aig  =%6d",  Abc_NtkGetAigNodeNum(pNtk) - nSingles );
    else if ( Abc_NtkHasBdd(pNtk) )
        Abc_Print( 1,"  bdd  =%6d",  Abc_NtkGetBddNodeNum(pNtk) - nSingles );
    else if ( Abc_NtkHasMapping(pNtk) )
    {
        int fHasTimeMan = (int)(pNtk->pManTime != NULL);
        assert( pNtk->pManFunc == Abc_FrameReadLibGen() );
        Abc_Print( 1,"  area =%5.2f", Abc_NtkGetMappedArea(pNtk) );
        Abc_Print( 1,"  delay =%5.2f", Abc_NtkDelayTrace(pNtk, NULL, NULL, 0) );
        if ( !fHasTimeMan && pNtk->pManTime )
        {
            Abc_ManTimeStop( pNtk->pManTime );
            pNtk->pManTime = NULL;
        }
    }
    else if ( !Abc_NtkHasBlackbox(pNtk) )
    {
        assert( 0 );
    }
 
    if ( Abc_NtkIsStrash(pNtk) )
    {
        extern int Abc_NtkGetMultiRefNum( Abc_Ntk_t * pNtk );
        Abc_Print( 1,"  lev =%3d", Abc_AigLevel(pNtk) );
//        Abc_Print( 1,"  ff = %5d", Abc_NtkNodeNum(pNtk) + 2 * (Abc_NtkCoNum(pNtk)+Abc_NtkGetMultiRefNum(pNtk)) );
//        Abc_Print( 1,"  var = %5d", Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk)+Abc_NtkGetMultiRefNum(pNtk) );
    }
    else
        Abc_Print( 1,"  lev = %d", Abc_NtkLevel(pNtk) );
    if ( pNtk->nBarBufs2 )
        Abc_Print( 1,"  buf = %d", pNtk->nBarBufs2 );
    if ( fUseLutLib && Abc_FrameReadLibLut() )
        Abc_Print( 1,"  delay =%5.2f", Abc_NtkDelayTraceLut(pNtk, 1) );
    if ( fUseLutLib && Abc_FrameReadLibLut() )
        Abc_Print( 1,"  area =%5.2f", Abc_NtkGetArea(pNtk) );
    if ( fPower )
        Abc_Print( 1,"  power =%7.2f", Abc_NtkMfsTotalSwitching(pNtk) );
    if ( fGlitch )
    {
        if ( Abc_NtkIsLogic(pNtk) && Abc_NtkGetFaninMax(pNtk) <= 6 )
            Abc_Print( 1,"  glitch =%7.2f %%", Abc_NtkMfsTotalGlitching(pNtk, 4000, 8, 0) );
        else
            printf( "\nCurrently computes glitching only for K-LUT networks with K <= 6." );
    }
    if ( fPrintMem )
        Abc_Print( 1,"  mem =%5.2f MB", Abc_NtkMemory(pNtk)/(1<<20) );
    Abc_Print( 1,"\n" );
/*
    // print the statistic into a file
    if ( fDumpResult )
    {
        FILE * pTable = fopen( "abcstats.txt", "a+" );
        fprintf( pTable, "%s ",  pNtk->pName );
        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkGetTotalFanins(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkLevel(pNtk) );
        fprintf( pTable, "\n" );
        fclose( pTable );
    }
*/
 
/*
    {
        FILE * pTable;
        pTable = fopen( "ibm/seq_stats.txt", "a+" );
//        fprintf( pTable, "%s ",  pNtk->pName );
//        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkLatchNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkLevel(pNtk) );
        fprintf( pTable, "\n" );
        fclose( pTable );
    }
*/
 
/*
    // print the statistic into a file
    {
        FILE * pTable;
        pTable = fopen( "x/stats_new.txt", "a+" );
        fprintf( pTable, "%s ",  pNtk->pName );
//        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkLevel(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkGetTotalFanins(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkLatchNum(pNtk) );
//        fprintf( pTable, "%.2f ", (float)(s_MappingMem)/(float)(1<<20) );
        fprintf( pTable, "%.2f", (float)(s_MappingTime)/(float)(CLOCKS_PER_SEC) );
//        fprintf( pTable, "%.2f", (float)(s_ResynTime)/(float)(CLOCKS_PER_SEC) );
        fprintf( pTable, "\n" );
        fclose( pTable );
 
        s_ResynTime = 0;
    }
*/
 
/*
    // print the statistic into a file
    {
        static int Counter = 0;
        extern int timeRetime;
        FILE * pTable;
        Counter++;
        pTable = fopen( "d/stats.txt", "a+" );
        fprintf( pTable, "%s ", pNtk->pName );
//        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkLatchNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fprintf( pTable, "%.2f ", (float)(timeRetime)/(float)(CLOCKS_PER_SEC) );
        fprintf( pTable, "\n" );
        fclose( pTable );
    }
 
 
    s_TotalNodes += Abc_NtkNodeNum(pNtk);
    printf( "Total nodes = %6d   %6.2f MB   Changes = %6d.\n", 
        s_TotalNodes, s_TotalNodes * 20.0 / (1<<20), s_TotalChanges );
*/
 
//    if ( Abc_NtkHasSop(pNtk) )
//        printf( "The total number of cube pairs = %d.\n", Abc_NtkGetCubePairNum(pNtk) );
 
    if ( 0 )
    {
        FILE * pTable = fopen( "stats.txt", "a+" );
        if ( Abc_NtkIsStrash(pNtk) )
        fprintf( pTable, "%s ", pNtk->pName );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fclose( pTable );
    }
 
    fflush( stdout );
    if ( pNtk->pExdc )
        Abc_NtkPrintStats( pNtk->pExdc, fFactored, fSaveBest, fDumpResult, fUseLutLib, fPrintMuxes, fPower, fGlitch, fSkipBuf, fSkipSmall, fPrintMem );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkPrintStrSupports()

void Abc_NtkPrintStrSupports	(	Abc_Ntk_t *	pNtk,
		int	fMatrix )

Definition at line 1620 of file abcPrint.c.

{
    Vec_Ptr_t * vSupp, * vNodes;
    Abc_Obj_t * pObj;
    int i, k, nPis;
    printf( "Structural support info:\n" );
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        vSupp  = Abc_NtkNodeSupport( pNtk, &pObj, 1 );
        vNodes = Abc_NtkDfsNodes( pNtk, &pObj, 1 );
        nPis   = Abc_NtkCountPis( vSupp );
        printf( "%5d  %20s :  Cone = %5d.  Supp = %5d. (PIs = %5d. FFs = %5d.)\n",
            i, Abc_ObjName(pObj), vNodes->nSize, vSupp->nSize, nPis, vSupp->nSize - nPis );
        Vec_PtrFree( vNodes );
        Vec_PtrFree( vSupp );
    }
    if ( !fMatrix )
    {
        Abc_NtkCleanMarkA( pNtk );
        return;
    }
 
    Abc_NtkForEachCi( pNtk, pObj, k )
        pObj->fMarkA = 0;
 
    printf( "Actual support info:\n" );
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        vSupp  = Abc_NtkNodeSupport( pNtk, &pObj, 1 );
        Vec_PtrForEachEntry( Abc_Obj_t *, vSupp, pObj, k )
            pObj->fMarkA = 1;
        Vec_PtrFree( vSupp );
 
        Abc_NtkForEachCi( pNtk, pObj, k )
            printf( "%d", pObj->fMarkA );
        printf( "\n" );
 
        Abc_NtkForEachCi( pNtk, pObj, k )
            pObj->fMarkA = 0;
    }
    Abc_NtkCleanMarkA( pNtk );
}

Here is the call graph for this function:

Abc_NtkShow6VarFunc()

void Abc_NtkShow6VarFunc	(	char *	pF0,
		char *	pF1 )

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

Synopsis [Prints K-map of 6-var function represented by truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 2089 of file abcPrint.c.

{
    word F0, F1;
    if ( strlen(pF0) != 16 )
    {
        printf( "Wrong length (%d) of 6-var truth table.\n", (int)strlen(pF0) );
        return;
    }
    if ( strlen(pF1) != 16 )
    {
        printf( "Wrong length (%d) of 6-var truth table.\n", (int)strlen(pF1) );
        return;
    }
    Extra_ReadHexadecimal( (unsigned *)&F0, pF0, 6 );
    Extra_ReadHexadecimal( (unsigned *)&F1, pF1, 6 );
    Abc_Show6VarFunc( F0, F1 );
}

Here is the call graph for this function:

Abc_ObjPrint()

void Abc_ObjPrint	(	FILE *	pFile,
		Abc_Obj_t *	pObj )

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

Synopsis [Prints information about the object.]

Description []

SideEffects []

SeeAlso []

Definition at line 1674 of file abcPrint.c.

{
    Abc_Obj_t * pFanin;
    int i;
    fprintf( pFile, "Object %5d : ", pObj->Id );
    switch ( pObj->Type )
    {
        case ABC_OBJ_NONE:
            fprintf( pFile, "NONE   " );
            break;
        case ABC_OBJ_CONST1:
            fprintf( pFile, "Const1 " );
            break;
        case ABC_OBJ_PI:
            fprintf( pFile, "PI     " );
            break;
        case ABC_OBJ_PO:
            fprintf( pFile, "PO     " );
            break;
        case ABC_OBJ_BI:
            fprintf( pFile, "BI     " );
            break;
        case ABC_OBJ_BO:
            fprintf( pFile, "BO     " );
            break;
        case ABC_OBJ_NET:
            fprintf( pFile, "Net    " );
            break;
        case ABC_OBJ_NODE:
            fprintf( pFile, "Node   " );
            break;
        case ABC_OBJ_LATCH:
            fprintf( pFile, "Latch  " );
            break;
        case ABC_OBJ_WHITEBOX:
            fprintf( pFile, "Whitebox" );
            break;
        case ABC_OBJ_BLACKBOX:
            fprintf( pFile, "Blackbox" );
            break;
        default:
            assert(0);
            break;
    }
    // print the fanins
    fprintf( pFile, " Fanins ( " );
    Abc_ObjForEachFanin( pObj, pFanin, i )
        fprintf( pFile, "%d ", pFanin->Id );
    fprintf( pFile, ") " );
/*
    fprintf( pFile, " Fanouts ( " );
    Abc_ObjForEachFanout( pObj, pFanin, i )
        fprintf( pFile, "%d(%c) ", pFanin->Id, Abc_NodeIsTravIdCurrent(pFanin)? '+' : '-' );
    fprintf( pFile, ") " );
*/
    // print the logic function
    if ( Abc_ObjIsNode(pObj) && Abc_NtkIsSopLogic(pObj->pNtk) )
        fprintf( pFile, " %s", (char*)pObj->pData );
    else if ( Abc_ObjIsNode(pObj) && Abc_NtkIsMappedLogic(pObj->pNtk) )
        fprintf( pFile, " %s\n", Mio_GateReadName((Mio_Gate_t *)pObj->pData) );
    else
        fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_Show6VarFunc()

void Abc_Show6VarFunc	(	word	F0,
		word	F1 )

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

Synopsis [Prints K-map of 6-var function represented by truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 2007 of file abcPrint.c.

{
    // order of cells in the Karnaugh map
//    int Cells[8] = { 0, 1, 3, 2, 6, 7, 5, 4 };
    int Cells[8] = { 0, 4, 6, 2, 3, 7, 5, 1 };
    // intermediate variables
    int s; // symbol counter
    int h; // horizontal coordinate;
    int v; // vertical coordinate;
    assert( (F0 & F1) == 0 );
 
    // output minterms above
    for ( s = 0; s < 4; s++ )
        printf( " " );
    printf( " " );
    for ( h = 0; h < 8; h++ )
    {
        for ( s = 0; s < 3; s++ )
            printf( "%d",  ((Cells[h] >> (2-s)) & 1) );
        printf( " " );
    }
    printf( "\n" );
 
    // output horizontal line above
    for ( s = 0; s < 4; s++ )
        printf( " " );
    printf( "+" );
    for ( h = 0; h < 8; h++ )
    {
        for ( s = 0; s < 3; s++ )
            printf( "-" );
        printf( "+" );
    }
    printf( "\n" );
 
    // output lines with function values
    for ( v = 0; v < 8; v++ )
    {
        for ( s = 0; s < 3; s++ )
            printf( "%d",  ((Cells[v] >> (2-s)) & 1) );
        printf( " |" );
 
        for ( h = 0; h < 8; h++ )
        {
            printf( " " );
            if ( ((F0 >> ((Cells[v]*8)+Cells[h])) & 1) )
                printf( "0" );
            else if ( ((F1 >> ((Cells[v]*8)+Cells[h])) & 1) )
                printf( "1" );
            else
                printf( " " );
            printf( " |" );
        }
        printf( "\n" );
 
        // output horizontal line above
        for ( s = 0; s < 4; s++ )
            printf( " " );
//        printf( "%c", v == 7 ? '+' : '|' );
        printf( "+" );
        for ( h = 0; h < 8; h++ )
        {
            for ( s = 0; s < 3; s++ )
                printf( "-" );
//            printf( "%c", v == 7 ? '+' : '|' );
            printf( "%c", (v == 7 || h == 7) ? '+' : '|' );
        }
        printf( "\n" );
    }
}

Here is the caller graph for this function:

Gli_ManAlloc()

Gli_Man_t * Gli_ManAlloc ( int nObjs, int nRegs, int nFanioPairs )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 144 of file giaGlitch.c.

{
    Gli_Man_t * p;
    p = (Gli_Man_t *)ABC_CALLOC( int, (sizeof(Gli_Man_t) / 4) + (sizeof(Gli_Obj_t) / 4) * nObjs + 2 * nFanioPairs );
    p->nRegs = nRegs;
    p->vCis = Vec_IntAlloc( 1000 );
    p->vCos = Vec_IntAlloc( 1000 );
    p->vCisChanged = Vec_IntAlloc( 1000 );
    p->vAffected = Vec_IntAlloc( 1000 );
    p->vFrontier = Vec_IntAlloc( 1000 );
    p->nObjData = (sizeof(Gli_Obj_t) / 4) * nObjs + 2 * nFanioPairs;
    p->pObjData = (int *)(p + 1);
    return p;
}

Here is the caller graph for this function:

Gli_ManCreateCi()

int Gli_ManCreateCi ( Gli_Man_t * p, int nFanouts )

extern

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

Synopsis [Creates CI.]

Description []

SideEffects []

SeeAlso []

Definition at line 288 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    pObj = Gli_ObjAlloc( p, 0, nFanouts );
    pObj->fTerm = 1;
    Vec_IntPush( p->vCis, pObj->Handle );
    return pObj->Handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gli_ManCreateCo()

int Gli_ManCreateCo ( Gli_Man_t * p, int iFanin )

extern

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

Synopsis [Creates CO.]

Description []

SideEffects []

SeeAlso []

Definition at line 308 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pFanin;
    pObj = Gli_ObjAlloc( p, 1, 0 );
    pObj->fTerm = 1;
    pFanin = Gli_ManObj( p, iFanin );
    Gli_ObjAddFanin( pObj, pFanin );
    pObj->fPhase = pObj->fPhase2 = pFanin->fPhase;
    Vec_IntPush( p->vCos, pObj->Handle );
    return pObj->Handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gli_ManCreateNode()

int Gli_ManCreateNode ( Gli_Man_t * p, Vec_Int_t * vFanins, int nFanouts, word * pGateTruth )

extern

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

Synopsis [Creates node.]

Description []

SideEffects []

SeeAlso []

Definition at line 369 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pFanin;
    int i;
    assert( Vec_IntSize(vFanins) <= 16 );
    pObj = Gli_ObjAlloc( p, Vec_IntSize(vFanins), nFanouts );
    Gli_ManForEachEntry( vFanins, p, pFanin, i )
        Gli_ObjAddFanin( pObj, pFanin );
    pObj->pTruth = pGateTruth;
    pObj->fPhase = pObj->fPhase2 = Gli_NodeComputeValue( pObj );
    return pObj->Handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gli_ManStop()

void Gli_ManStop ( Gli_Man_t * p )

extern

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

Synopsis [Deletes logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file giaGlitch.c.

{
    Vec_IntFree( p->vCis );
    Vec_IntFree( p->vCos );
    Vec_IntFree( p->vCisChanged );
    Vec_IntFree( p->vAffected );
    Vec_IntFree( p->vFrontier );
    ABC_FREE( p->pSimInfoPrev );
    ABC_FREE( p );
}

Here is the caller graph for this function:

Gli_ManSwitchesAndGlitches()

void Gli_ManSwitchesAndGlitches ( Gli_Man_t * p, int nPatterns, float PiTransProb, int fVerbose )

extern

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

Synopsis [Computes glitching activity of each node.]

Description []

SideEffects []

SeeAlso []

Definition at line 740 of file giaGlitch.c.

{
    int i, k;
    abctime clk = Abc_Clock();
    Gia_ManRandom( 1 );
    Gli_ManFinalize( p );
    if ( p->nRegs == 0 )
    {
        for ( i = 0; i < nPatterns; i++ )
        {
            Gli_ManSetPiRandom( p, PiTransProb );
            Gli_ManSwitching( p );
            Gli_ManGlitching( p );
//            Gli_ManVerify( p );
        }
    }
    else 
    {
        int nIters = Abc_BitWordNum(nPatterns);
        Gli_ManSimulateSeqPref( p, 16 );
        for ( i = 0; i < 32; i++ )
        {
            Gli_ManSetDataSaved( p, i );
            for ( k = 0; k < nIters; k++ )
            {
                Gli_ManSetPiRandomSeq( p, PiTransProb );
                Gli_ManSwitching( p );
                Gli_ManGlitching( p );
//                Gli_ManVerify( p );
            }
        }
    }
    if ( fVerbose )
    {
        printf( "Simulated %d patterns.  Input transition probability %.2f.  ", nPatterns, PiTransProb );
        ABC_PRMn( "Memory", 4*p->nObjData );
        ABC_PRT( "Time", Abc_Clock() - clk );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gli_ObjNumGlitches()

int Gli_ObjNumGlitches ( Gli_Man_t * p, int iNode )

extern

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

Synopsis [Returns the number of glitches of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 409 of file giaGlitch.c.

{
    return Gli_ManObj( p, iNode )->nGlitches;
}

Here is the caller graph for this function:

Gli_ObjNumSwitches()

int Gli_ObjNumSwitches ( Gli_Man_t * p, int iNode )

extern

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

Synopsis [Returns the number of switches of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 393 of file giaGlitch.c.

{
    return Gli_ManObj( p, iNode )->nSwitches;
}

Here is the caller graph for this function:

Variable Documentation

s_MappingMem

int s_MappingMem = 0

Definition at line 48 of file abcPrint.c.

s_MappingTime

ABC_NAMESPACE_IMPL_START abctime s_MappingTime = 0

DECLARATIONS ///.

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

FileName [abcPrint.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Printing statistics.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

abcPrint.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 47 of file abcPrint.c.

s_ResynTime

abctime s_ResynTime = 0

Definition at line 50 of file abcPrint.c.