nwk.h File Reference

#include "aig/aig/aig.h"
#include "aig/hop/hop.h"
#include "misc/tim/tim.h"
#include "map/if/if.h"
#include "bool/bdc/bdc.h"
#include "proof/fra/fra.h"
#include "proof/ssw/ssw.h"
#include "ntlnwk.h"

Go to the source code of this file.

Data Structures
struct	Nwk_Man_t_
struct	Nwk_Obj_t_

Macros
#define	Nwk_ManForEachCi(p, pObj, i)   Vec_PtrForEachEntry( Nwk_Obj_t *, p->vCis, pObj, i )
	ITERATORS ///. More...
#define	Nwk_ManForEachCo(p, pObj, i)   Vec_PtrForEachEntry( Nwk_Obj_t *, p->vCos, pObj, i )
#define	Nwk_ManForEachPi(p, pObj, i)
#define	Nwk_ManForEachPo(p, pObj, i)
#define	Nwk_ManForEachObj(p, pObj, i)
#define	Nwk_ManForEachNode(p, pObj, i)
#define	Nwk_ManForEachLatch(p, pObj, i)
#define	Nwk_ObjForEachFanin(pObj, pFanin, i)   for ( i = 0; (i < (int)(pObj)->nFanins) && ((pFanin) = (pObj)->pFanio[i]); i++ )
#define	Nwk_ObjForEachFanout(pObj, pFanout, i)   for ( i = 0; (i < (int)(pObj)->nFanouts) && ((pFanout) = (pObj)->pFanio[(pObj)->nFanins+i]); i++ )
#define	Nwk_ManForEachPiSeq(p, pObj, i)   Vec_PtrForEachEntryStop( Nwk_Obj_t *, p->vCis, pObj, i, (p)->nTruePis )
#define	Nwk_ManForEachPoSeq(p, pObj, i)   Vec_PtrForEachEntryStop( Nwk_Obj_t *, p->vCos, pObj, i, (p)->nTruePos )
#define	Nwk_ManForEachLoSeq(p, pObj, i)   for ( i = 0; (i < (p)->nLatches) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vCis, i+(p)->nTruePis)), 1); i++ )
#define	Nwk_ManForEachLiSeq(p, pObj, i)   for ( i = 0; (i < (p)->nLatches) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vCos, i+(p)->nTruePos)), 1); i++ )
#define	Nwk_ManForEachLiLoSeq(p, pObjLi, pObjLo, i)

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Nwk_Obj_t_	Nwk_Obj_t
	INCLUDES ///. More...

Enumerations
enum	Nwk_Type_t {   NWK_OBJ_NONE, NWK_OBJ_CI, NWK_OBJ_CO, NWK_OBJ_NODE,   NWK_OBJ_LATCH, NWK_OBJ_VOID }

Functions
static int	Nwk_ManCiNum (Nwk_Man_t *p)
	MACRO DEFINITIONS ///. More...
static int	Nwk_ManCoNum (Nwk_Man_t *p)
static int	Nwk_ManNodeNum (Nwk_Man_t *p)
static int	Nwk_ManLatchNum (Nwk_Man_t *p)
static int	Nwk_ManObjNumMax (Nwk_Man_t *p)
static Nwk_Obj_t *	Nwk_ManCi (Nwk_Man_t *p, int i)
static Nwk_Obj_t *	Nwk_ManCo (Nwk_Man_t *p, int i)
static Nwk_Obj_t *	Nwk_ManObj (Nwk_Man_t *p, int i)
static int	Nwk_ObjId (Nwk_Obj_t *p)
static int	Nwk_ObjPioNum (Nwk_Obj_t *p)
static int	Nwk_ObjFaninNum (Nwk_Obj_t *p)
static int	Nwk_ObjFanoutNum (Nwk_Obj_t *p)
static Nwk_Obj_t *	Nwk_ObjFanin0 (Nwk_Obj_t *p)
static Nwk_Obj_t *	Nwk_ObjFanout0 (Nwk_Obj_t *p)
static Nwk_Obj_t *	Nwk_ObjFanin (Nwk_Obj_t *p, int i)
static Nwk_Obj_t *	Nwk_ObjFanout (Nwk_Obj_t *p, int i)
static int	Nwk_ObjIsNone (Nwk_Obj_t *p)
static int	Nwk_ObjIsCi (Nwk_Obj_t *p)
static int	Nwk_ObjIsCo (Nwk_Obj_t *p)
static int	Nwk_ObjIsNode (Nwk_Obj_t *p)
static int	Nwk_ObjIsLatch (Nwk_Obj_t *p)
static int	Nwk_ObjIsPi (Nwk_Obj_t *p)
static int	Nwk_ObjIsPo (Nwk_Obj_t *p)
static int	Nwk_ObjIsLi (Nwk_Obj_t *p)
static int	Nwk_ObjIsLo (Nwk_Obj_t *p)
static float	Nwk_ObjArrival (Nwk_Obj_t *pObj)
static float	Nwk_ObjRequired (Nwk_Obj_t *pObj)
static float	Nwk_ObjSlack (Nwk_Obj_t *pObj)
static void	Nwk_ObjSetArrival (Nwk_Obj_t *pObj, float Time)
static void	Nwk_ObjSetRequired (Nwk_Obj_t *pObj, float Time)
static void	Nwk_ObjSetSlack (Nwk_Obj_t *pObj, float Time)
static int	Nwk_ObjLevel (Nwk_Obj_t *pObj)
static void	Nwk_ObjSetLevel (Nwk_Obj_t *pObj, int Level)
static void	Nwk_ObjSetTravId (Nwk_Obj_t *pObj, int TravId)
static void	Nwk_ObjSetTravIdCurrent (Nwk_Obj_t *pObj)
static void	Nwk_ObjSetTravIdPrevious (Nwk_Obj_t *pObj)
static int	Nwk_ObjIsTravIdCurrent (Nwk_Obj_t *pObj)
static int	Nwk_ObjIsTravIdPrevious (Nwk_Obj_t *pObj)
static int	Nwk_ManTimeEqual (float f1, float f2, float Eps)
static int	Nwk_ManTimeLess (float f1, float f2, float Eps)
static int	Nwk_ManTimeMore (float f1, float f2, float Eps)
ABC_DLL Vec_Ptr_t *	Nwk_ManDeriveRetimingCut (Aig_Man_t *p, int fForward, int fVerbose)
	FUNCTION DECLARATIONS ///. More...
ABC_DLL void	Nwk_ManBidecResyn (Nwk_Man_t *pNtk, int fVerbose)
ABC_DLL Hop_Obj_t *	Nwk_NodeIfNodeResyn (Bdc_Man_t *p, Hop_Man_t *pHop, Hop_Obj_t *pRoot, int nVars, Vec_Int_t *vTruth, unsigned *puCare, float dProb)
	FUNCTION DEFINITIONS ///. More...
ABC_DLL int	Nwk_ManCheck (Nwk_Man_t *p)
	DECLARATIONS ///. More...
ABC_DLL int	Nwk_ManVerifyTopoOrder (Nwk_Man_t *pNtk)
	DECLARATIONS ///. More...
ABC_DLL int	Nwk_ManLevelBackup (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManLevel (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManLevelMax (Nwk_Man_t *pNtk)
ABC_DLL Vec_Vec_t *	Nwk_ManLevelize (Nwk_Man_t *pNtk)
ABC_DLL Vec_Ptr_t *	Nwk_ManDfs (Nwk_Man_t *pNtk)
ABC_DLL Vec_Ptr_t *	Nwk_ManDfsNodes (Nwk_Man_t *pNtk, Nwk_Obj_t **ppNodes, int nNodes)
ABC_DLL Vec_Ptr_t *	Nwk_ManDfsReverse (Nwk_Man_t *pNtk)
ABC_DLL Vec_Ptr_t *	Nwk_ManSupportNodes (Nwk_Man_t *pNtk, Nwk_Obj_t **ppNodes, int nNodes)
ABC_DLL void	Nwk_ManSupportSum (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ObjMffcLabel (Nwk_Obj_t *pNode)
ABC_DLL void	Nwk_ObjCollectFanins (Nwk_Obj_t *pNode, Vec_Ptr_t *vNodes)
	DECLARATIONS ///. More...
ABC_DLL void	Nwk_ObjCollectFanouts (Nwk_Obj_t *pNode, Vec_Ptr_t *vNodes)
ABC_DLL int	Nwk_ObjFindFanin (Nwk_Obj_t *pObj, Nwk_Obj_t *pFanin)
ABC_DLL int	Nwk_ObjFindFanout (Nwk_Obj_t *pObj, Nwk_Obj_t *pFanout)
ABC_DLL void	Nwk_ObjAddFanin (Nwk_Obj_t *pObj, Nwk_Obj_t *pFanin)
ABC_DLL void	Nwk_ObjDeleteFanin (Nwk_Obj_t *pObj, Nwk_Obj_t *pFanin)
ABC_DLL void	Nwk_ObjPatchFanin (Nwk_Obj_t *pObj, Nwk_Obj_t *pFaninOld, Nwk_Obj_t *pFaninNew)
ABC_DLL void	Nwk_ObjTransferFanout (Nwk_Obj_t *pNodeFrom, Nwk_Obj_t *pNodeTo)
ABC_DLL void	Nwk_ObjReplace (Nwk_Obj_t *pNodeOld, Nwk_Obj_t *pNodeNew)
ABC_DLL Vec_Ptr_t *	Nwk_ManRetimeCutForward (Nwk_Man_t *pMan, int nLatches, int fVerbose)
ABC_DLL Vec_Ptr_t *	Nwk_ManRetimeCutBackward (Nwk_Man_t *pMan, int nLatches, int fVerbose)
ABC_DLL Nwk_Man_t *	Nwk_ManAlloc ()
	DECLARATIONS ///. More...
ABC_DLL void	Nwk_ManFree (Nwk_Man_t *p)
ABC_DLL float	Nwl_ManComputeTotalSwitching (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManPrintStats (Nwk_Man_t *p, If_LibLut_t *pLutLib, int fSaveBest, int fDumpResult, int fPower, Ntl_Man_t *pNtl)
ABC_DLL Nwk_Man_t *	Nwk_MappingIf (Aig_Man_t *p, Tim_Man_t *pManTime, If_Par_t *pPars)
ABC_DLL Nwk_Obj_t *	Nwk_ManCreateCi (Nwk_Man_t *pMan, int nFanouts)
ABC_DLL Nwk_Obj_t *	Nwk_ManCreateCo (Nwk_Man_t *pMan)
ABC_DLL Nwk_Obj_t *	Nwk_ManCreateNode (Nwk_Man_t *pMan, int nFanins, int nFanouts)
ABC_DLL Nwk_Obj_t *	Nwk_ManCreateBox (Nwk_Man_t *pMan, int nFanins, int nFanouts)
ABC_DLL Nwk_Obj_t *	Nwk_ManCreateLatch (Nwk_Man_t *pMan)
ABC_DLL void	Nwk_ManDeleteNode (Nwk_Obj_t *pObj)
ABC_DLL void	Nwk_ManDeleteNode_rec (Nwk_Obj_t *pObj)
ABC_DLL Aig_Man_t *	Nwk_ManSpeedup (Nwk_Man_t *pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose)
ABC_DLL Aig_Man_t *	Nwk_ManStrash (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManVerifyTiming (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManDelayTraceSortPins (Nwk_Obj_t *pNode, int *pPinPerm, float *pPinDelays)
ABC_DLL float	Nwk_ManDelayTraceLut (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManDelayTracePrint (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManUpdate (Nwk_Obj_t *pObj, Nwk_Obj_t *pObjNew, Vec_Vec_t *vLevels)
ABC_DLL int	Nwk_ManVerifyLevel (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManIncrementTravId (Nwk_Man_t *pNtk)
	DECLARATIONS ///. More...
ABC_DLL int	Nwk_ManGetFaninMax (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManGetTotalFanins (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManPiNum (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManPoNum (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_ManGetAigNodeNum (Nwk_Man_t *pNtk)
ABC_DLL int	Nwk_NodeCompareLevelsIncrease (Nwk_Obj_t **pp1, Nwk_Obj_t **pp2)
ABC_DLL int	Nwk_NodeCompareLevelsDecrease (Nwk_Obj_t **pp1, Nwk_Obj_t **pp2)
ABC_DLL void	Nwk_ObjPrint (Nwk_Obj_t *pObj)
ABC_DLL void	Nwk_ManDumpBlif (Nwk_Man_t *pNtk, char *pFileName, Vec_Ptr_t *vCiNames, Vec_Ptr_t *vCoNames)
ABC_DLL void	Nwk_ManPrintFanioNew (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManCleanMarks (Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManMinimumBase (Nwk_Man_t *pNtk, int fVerbose)
ABC_DLL void	Nwk_ManRemoveDupFanins (Nwk_Man_t *pNtk, int fVerbose)

Macro Definition Documentation

#define Nwk_ManForEachCi	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Nwk_Obj_t *, p->vCis, pObj, i )

ITERATORS ///.

Definition at line 179 of file nwk.h.

#define Nwk_ManForEachCo	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Nwk_Obj_t *, p->vCos, pObj, i )

Definition at line 181 of file nwk.h.

#define Nwk_ManForEachLatch	(		p,
			pObj,
			i
	)

Value:

for ( i = 0; (i < Vec_PtrSize(p->vObjs)) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vObjs, i)), 1); i++ ) \
        if ( (pObj) == NULL || !Nwk_ObjIsLatch(pObj) ) {} else

Definition at line 195 of file nwk.h.

#define Nwk_ManForEachLiLoSeq	(		p,
			pObjLi,
			pObjLo,
			i
	)

Value:

for ( i = 0; (i < (p)->nLatches) && (((pObjLi) = Nwk_ManCo(p, i+(p)->nTruePos)), 1)        \
        && (((pObjLo) = Nwk_ManCi(p, i+(p)->nTruePis)), 1); i++ )

Definition at line 213 of file nwk.h.

#define Nwk_ManForEachLiSeq	(		p,
			pObj,
			i
	)		for ( i = 0; (i < (p)->nLatches) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vCos, i+(p)->nTruePos)), 1); i++ )

Definition at line 211 of file nwk.h.

#define Nwk_ManForEachLoSeq	(		p,
			pObj,
			i
	)		for ( i = 0; (i < (p)->nLatches) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vCis, i+(p)->nTruePis)), 1); i++ )

Definition at line 209 of file nwk.h.

#define Nwk_ManForEachNode	(		p,
			pObj,
			i
	)

Value:

for ( i = 0; (i < Vec_PtrSize(p->vObjs)) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vObjs, i)), 1); i++ ) \
        if ( (pObj) == NULL || !Nwk_ObjIsNode(pObj) ) {} else

Definition at line 192 of file nwk.h.

#define Nwk_ManForEachObj	(		p,
			pObj,
			i
	)

Value:

for ( i = 0; (i < Vec_PtrSize(p->vObjs)) && (((pObj) = (Nwk_Obj_t *)Vec_PtrEntry(p->vObjs, i)), 1); i++ ) \
        if ( pObj == NULL ) {} else

Definition at line 189 of file nwk.h.

#define Nwk_ManForEachPi	(		p,
			pObj,
			i
	)

Value:

Vec_PtrForEachEntry( Nwk_Obj_t *, p->vCis, pObj, i )                                \
        if ( !Nwk_ObjIsPi(pObj) ) {} else

Definition at line 183 of file nwk.h.

#define Nwk_ManForEachPiSeq	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntryStop( Nwk_Obj_t *, p->vCis, pObj, i, (p)->nTruePis )

Definition at line 205 of file nwk.h.

#define Nwk_ManForEachPo	(		p,
			pObj,
			i
	)

Value:

Vec_PtrForEachEntry( Nwk_Obj_t *, p->vCos, pObj, i )                                \
        if ( !Nwk_ObjIsPo(pObj) ) {} else

Definition at line 186 of file nwk.h.

#define Nwk_ManForEachPoSeq	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntryStop( Nwk_Obj_t *, p->vCos, pObj, i, (p)->nTruePos )

Definition at line 207 of file nwk.h.

#define Nwk_ObjForEachFanin	(		pObj,
			pFanin,
			i
	)		for ( i = 0; (i < (int)(pObj)->nFanins) && ((pFanin) = (pObj)->pFanio[i]); i++ )

Definition at line 199 of file nwk.h.

#define Nwk_ObjForEachFanout	(		pObj,
			pFanout,
			i
	)		for ( i = 0; (i < (int)(pObj)->nFanouts) && ((pFanout) = (pObj)->pFanio[(pObj)->nFanins+i]); i++ )

Definition at line 201 of file nwk.h.

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct Nwk_Obj_t_ Nwk_Obj_t

INCLUDES ///.

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

FileName [nwk.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

nwk.h,v 1.1 2008/05/14 22:13:09 wudenni Exp

]PARAMETERS ///BASIC TYPES ///

Definition at line 49 of file nwk.h.

Enumeration Type Documentation

enum Nwk_Type_t

Enumerator
NWK_OBJ_NONE
NWK_OBJ_CI
NWK_OBJ_CO
NWK_OBJ_NODE
NWK_OBJ_LATCH
NWK_OBJ_VOID

Definition at line 52 of file nwk.h.

             { 
    NWK_OBJ_NONE,                      // 0: non-existant object
    NWK_OBJ_CI,                        // 1: combinational input
    NWK_OBJ_CO,                        // 2: combinational output
    NWK_OBJ_NODE,                      // 3: logic node
    NWK_OBJ_LATCH,                     // 4: register
    NWK_OBJ_VOID                       // 5: unused object
} Nwk_Type_t;

Function Documentation

ABC_DLL Nwk_Man_t* Nwk_ManAlloc

(

)

DECLARATIONS ///.

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

FileName [nwkMan.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [Network manager.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

nwkMan.c,v 1.1 2008/10/10 14:09:30 mjarvin Exp

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

Synopsis [Allocates the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file nwkMan.c.

{
    Nwk_Man_t * p;
    p = ABC_ALLOC( Nwk_Man_t, 1 );
    memset( p, 0, sizeof(Nwk_Man_t) );
    p->vCis = Vec_PtrAlloc( 1000 );
    p->vCos = Vec_PtrAlloc( 1000 );
    p->vObjs = Vec_PtrAlloc( 1000 );
    p->vTemp = Vec_PtrAlloc( 1000 );
    p->nFanioPlus = 2;
    p->pMemObjs = Aig_MmFlexStart();
    p->pManHop = Hop_ManStart();
    return p;
}

ABC_DLL void Nwk_ManBidecResyn	(	Nwk_Man_t *	pNtk,
		int	fVerbose
	)

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

Synopsis [Resynthesizes nodes using bi-decomposition.]

Description []

SideEffects []

SeeAlso []

Definition at line 129 of file nwkBidec.c.

{
    Bdc_Par_t Pars = {0}, * pPars = &Pars;
    Bdc_Man_t * p;
    Nwk_Obj_t * pObj;
    Vec_Int_t * vTruth;
    int i, nGainTotal = 0, nNodes1, nNodes2;
    abctime clk = Abc_Clock();
    pPars->nVarsMax = Nwk_ManGetFaninMax( pNtk );
    pPars->fVerbose = fVerbose;
    if ( pPars->nVarsMax < 2 )
    {
        printf( "Resynthesis is not performed for networks whose nodes are less than 2 inputs.\n" );
        return;
    }
    if ( pPars->nVarsMax > 15 )
    {
        if ( fVerbose )
        printf( "Resynthesis is not performed for nodes with more than 15 inputs.\n" );
        pPars->nVarsMax = 15;
    }
    vTruth = Vec_IntAlloc( 0 );
    p = Bdc_ManAlloc( pPars );
    Nwk_ManForEachNode( pNtk, pObj, i )
    {
        if ( Nwk_ObjFaninNum(pObj) > 15 )
            continue;
        nNodes1 = Hop_DagSize(pObj->pFunc);
        pObj->pFunc = Nwk_NodeIfNodeResyn( p, pNtk->pManHop, pObj->pFunc, Nwk_ObjFaninNum(pObj), vTruth, NULL, -1.0 );
        nNodes2 = Hop_DagSize(pObj->pFunc);
        nGainTotal += nNodes1 - nNodes2;
    }
    Bdc_ManFree( p );
    Vec_IntFree( vTruth );
    if ( fVerbose )
    {
    printf( "Total gain in AIG nodes = %d.  ", nGainTotal );
    ABC_PRT( "Total runtime", Abc_Clock() - clk );
    }
}

ABC_DLL int Nwk_ManCheck

(

Nwk_Man_t *

p

)

DECLARATIONS ///.

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

FileName [nwkCheck.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [Consistency checking procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

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

Synopsis [Checking the logic network for consistency.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file nwkCheck.c.

{
    Nwk_Obj_t * pObj, * pNext;
    int i, k, m;
    // check if the nodes have duplicated fanins
    Nwk_ManForEachNode( p, pObj, i )
    {
        for ( k = 0; k < pObj->nFanins; k++ )
            for ( m = k + 1; m < pObj->nFanins; m++ )
                if ( pObj->pFanio[k] == pObj->pFanio[m] )
                    printf( "Node %d has duplicated fanin %d.\n", pObj->Id, pObj->pFanio[k]->Id );
    }
    // check if all nodes are in the correct fanin/fanout relationship
    Nwk_ManForEachObj( p, pObj, i )
    {
        Nwk_ObjForEachFanin( pObj, pNext, k )
            if ( Nwk_ObjFanoutNum(pNext) < 100 && Nwk_ObjFindFanout( pNext, pObj ) == -1 )
                printf( "Nwk_ManCheck(): Object %d has fanin %d which does not have a corresponding fanout.\n", pObj->Id, pNext->Id );
        Nwk_ObjForEachFanout( pObj, pNext, k )
            if ( Nwk_ObjFindFanin( pNext, pObj ) == -1 )
                printf( "Nwk_ManCheck(): Object %d has fanout %d which does not have a corresponding fanin.\n", pObj->Id, pNext->Id );
    }
    return 1;
}

static Nwk_Obj_t* Nwk_ManCi ( Nwk_Man_t *  p, int  i  )

inlinestatic

Definition at line 131 of file nwk.h.

{ return (Nwk_Obj_t *)Vec_PtrEntry( p->vCis, i );          } 

static int Nwk_ManCiNum ( Nwk_Man_t *  p )

inlinestatic

MACRO DEFINITIONS ///.

INLINED FUNCTIONS ///

Definition at line 125 of file nwk.h.

{ return p->nObjs[NWK_OBJ_CI];                } 

ABC_DLL void Nwk_ManCleanMarks

(

Nwk_Man_t *

pMan

)

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

Synopsis [Cleans the temporary marks of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 464 of file nwkUtil.c.

{
    Nwk_Obj_t * pObj;
    int i;
    Nwk_ManForEachObj( pMan, pObj, i )
        pObj->MarkA = pObj->MarkB = 0;
}

static Nwk_Obj_t* Nwk_ManCo ( Nwk_Man_t *  p, int  i  )

inlinestatic

Definition at line 132 of file nwk.h.

{ return (Nwk_Obj_t *)Vec_PtrEntry( p->vCos, i );          } 

static int Nwk_ManCoNum ( Nwk_Man_t *  p )

inlinestatic

Definition at line 126 of file nwk.h.

{ return p->nObjs[NWK_OBJ_CO];                } 

ABC_DLL Nwk_Obj_t* Nwk_ManCreateBox	(	Nwk_Man_t *	pMan,
		int	nFanins,
		int	nFanouts
	)

ABC_DLL Nwk_Obj_t* Nwk_ManCreateCi	(	Nwk_Man_t *	p,
		int	nFanouts
	)

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

Synopsis [Creates a primary input.]

Description []

SideEffects []

SeeAlso []

Definition at line 70 of file nwkObj.c.

{
    Nwk_Obj_t * pObj;
    pObj = Nwk_ManCreateObj( p, 1, nFanouts );
    pObj->PioId = Vec_PtrSize( p->vCis );
    Vec_PtrPush( p->vCis, pObj );
    pObj->Type = NWK_OBJ_CI;
    p->nObjs[NWK_OBJ_CI]++;
    return pObj;
}

ABC_DLL Nwk_Obj_t* Nwk_ManCreateCo

(

Nwk_Man_t *

p

)

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

Synopsis [Creates a primary output.]

Description []

SideEffects []

SeeAlso []

Definition at line 92 of file nwkObj.c.

{
    Nwk_Obj_t * pObj;
    pObj = Nwk_ManCreateObj( p, 1, 1 );
    pObj->PioId = Vec_PtrSize( p->vCos );
    Vec_PtrPush( p->vCos, pObj );
    pObj->Type = NWK_OBJ_CO;
    p->nObjs[NWK_OBJ_CO]++;
    return pObj;
}

ABC_DLL Nwk_Obj_t* Nwk_ManCreateLatch

(

Nwk_Man_t *

p

)

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

Synopsis [Creates a latch.]

Description []

SideEffects []

SeeAlso []

Definition at line 114 of file nwkObj.c.

{
    Nwk_Obj_t * pObj;
    pObj = Nwk_ManCreateObj( p, 1, 1 );
    pObj->Type = NWK_OBJ_LATCH;
    p->nObjs[NWK_OBJ_LATCH]++;
    return pObj;
}

ABC_DLL Nwk_Obj_t* Nwk_ManCreateNode	(	Nwk_Man_t *	p,
		int	nFanins,
		int	nFanouts
	)

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

Synopsis [Creates a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 134 of file nwkObj.c.

{
    Nwk_Obj_t * pObj;
    pObj = Nwk_ManCreateObj( p, nFanins, nFanouts );
    pObj->Type = NWK_OBJ_NODE;
    p->nObjs[NWK_OBJ_NODE]++;
    return pObj;
}

ABC_DLL float Nwk_ManDelayTraceLut

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the delay trace of the given network.]

Description []

SideEffects []

SeeAlso []

Definition at line 326 of file nwkTiming.c.

{
    Vec_Ptr_t * vObjs;
    int fUseSorting = 1;
    If_LibLut_t * pLutLib = pNtk->pLutLib;
    Vec_Ptr_t * vNodes;
    Nwk_Obj_t * pObj;
    float tArrival, tRequired, tSlack;
    int i;

    // get the library
    if ( pLutLib && pLutLib->LutMax < Nwk_ManGetFaninMax(pNtk) )
    {
        printf( "The max LUT size (%d) is less than the max fanin count (%d).\n", 
            pLutLib->LutMax, Nwk_ManGetFaninMax(pNtk) );
        return -TIM_ETERNITY;
    }

    // compute the reverse order of all objects
    vNodes = Nwk_ManDfsReverse( pNtk );

    // initialize the arrival times
    Nwk_ManCleanTiming( pNtk );

    // propagate arrival times
    if ( pNtk->pManTime )
        Tim_ManIncrementTravId( pNtk->pManTime );
//    Nwk_ManForEachObj( pNtk, pObj, i )
    vObjs = Nwk_ManDfs( pNtk );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vObjs, pObj, i )
    {
        tArrival = Nwk_NodeComputeArrival( pObj, fUseSorting );
        if ( Nwk_ObjIsCi(pObj) && pNtk->pManTime )
            tArrival = Tim_ManGetCiArrival( pNtk->pManTime, pObj->PioId );
        if ( Nwk_ObjIsCo(pObj) && pNtk->pManTime )
            Tim_ManSetCoArrival( pNtk->pManTime, pObj->PioId, tArrival );
        Nwk_ObjSetArrival( pObj, tArrival );
    }
    Vec_PtrFree( vObjs );

    // get the latest arrival times
    tArrival = -TIM_ETERNITY;
    Nwk_ManForEachPo( pNtk, pObj, i )
        if ( tArrival < Nwk_ObjArrival(pObj) )
            tArrival = Nwk_ObjArrival(pObj);

    // initialize the required times
    if ( pNtk->pManTime )
    {
        Tim_ManIncrementTravId( pNtk->pManTime );
        Tim_ManInitPoRequiredAll( pNtk->pManTime, tArrival );
    }
    else
    {
        Nwk_ManForEachCo( pNtk, pObj, i )
            Nwk_ObjSetRequired( pObj, tArrival );
    }

    // propagate the required times
    Vec_PtrForEachEntry( Nwk_Obj_t *, vNodes, pObj, i )
    {
        if ( Nwk_ObjIsNode(pObj) )
        {
            Nwk_NodePropagateRequired( pObj, fUseSorting );
        }
        else if ( Nwk_ObjIsCi(pObj) )
        {
            if ( pNtk->pManTime )
                Tim_ManSetCiRequired( pNtk->pManTime, pObj->PioId, Nwk_ObjRequired(pObj) );
        }
        else if ( Nwk_ObjIsCo(pObj) )
        {
            if ( pNtk->pManTime )
            {
                tRequired = Tim_ManGetCoRequired( pNtk->pManTime, pObj->PioId );
                Nwk_ObjSetRequired( pObj, tRequired );
            }
            if ( Nwk_ObjRequired(Nwk_ObjFanin0(pObj)) > Nwk_ObjRequired(pObj) )
                Nwk_ObjSetRequired( Nwk_ObjFanin0(pObj), Nwk_ObjRequired(pObj) );
        }

        // set slack for this object
        tSlack = Nwk_ObjRequired(pObj) - Nwk_ObjArrival(pObj);
        assert( tSlack + 0.01 > 0.0 );
        Nwk_ObjSetSlack( pObj, tSlack < 0.0 ? 0.0 : tSlack );
    }
    Vec_PtrFree( vNodes );
    return tArrival;
}

ABC_DLL void Nwk_ManDelayTracePrint

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Prints the delay trace for the given network.]

Description []

SideEffects []

SeeAlso []

Definition at line 459 of file nwkTiming.c.

{
    If_LibLut_t * pLutLib = pNtk->pLutLib;
    Nwk_Obj_t * pNode;
    int i, Nodes, * pCounters;
    float tArrival, tDelta, nSteps, Num;
    // get the library
    if ( pLutLib && pLutLib->LutMax < Nwk_ManGetFaninMax(pNtk) )
    {
        printf( "The max LUT size (%d) is less than the max fanin count (%d).\n", 
            pLutLib->LutMax, Nwk_ManGetFaninMax(pNtk) );
        return;
    }
    // decide how many steps
    nSteps = pLutLib ? 20 : Nwk_ManLevelMax(pNtk);
    pCounters = ABC_ALLOC( int, nSteps + 1 );
    memset( pCounters, 0, sizeof(int)*(nSteps + 1) );
    // perform delay trace
    tArrival = Nwk_ManDelayTraceLut( pNtk );
    tDelta = tArrival / nSteps;
    // count how many nodes have slack in the corresponding intervals
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( Nwk_ObjFaninNum(pNode) == 0 )
            continue;
        Num = Nwk_ObjSlack(pNode) / tDelta;
        if ( Num > nSteps )
            continue;
        assert( Num >=0 && Num <= nSteps );
        pCounters[(int)Num]++;
    }
    // print the results
    printf( "Max delay = %6.2f. Delay trace using %s model:\n", tArrival, pLutLib? "LUT library" : "unit-delay" );
    Nodes = 0;
    for ( i = 0; i < nSteps; i++ )
    {
        Nodes += pCounters[i];
        printf( "%3d %s : %5d  (%6.2f %%)\n", pLutLib? 5*(i+1) : i+1, 
            pLutLib? "%":"lev", Nodes, 100.0*Nodes/Nwk_ManNodeNum(pNtk) );
    }
    ABC_FREE( pCounters );
}

ABC_DLL void Nwk_ManDelayTraceSortPins	(	Nwk_Obj_t *	pNode,
		int *	pPinPerm,
		float *	pPinDelays
	)

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

Synopsis [Sorts the pins in the decreasing order of delays.]

Description []

SideEffects []

SeeAlso []

Definition at line 67 of file nwkTiming.c.

{
    Nwk_Obj_t * pFanin;
    int i, j, best_i, temp;
    // start the trivial permutation and collect pin delays
    Nwk_ObjForEachFanin( pNode, pFanin, i )
    {
        pPinPerm[i] = i;
        pPinDelays[i] = Nwk_ObjArrival(pFanin);
    }
    // selection sort the pins in the decreasible order of delays
    // this order will match the increasing order of LUT input pins
    for ( i = 0; i < Nwk_ObjFaninNum(pNode)-1; i++ )
    {
        best_i = i;
        for ( j = i+1; j < Nwk_ObjFaninNum(pNode); j++ )
            if ( pPinDelays[pPinPerm[j]] > pPinDelays[pPinPerm[best_i]] )
                best_i = j;
        if ( best_i == i )
            continue;
        temp = pPinPerm[i]; 
        pPinPerm[i] = pPinPerm[best_i]; 
        pPinPerm[best_i] = temp;
    }
    // verify
    assert( Nwk_ObjFaninNum(pNode) == 0 || pPinPerm[0] < Nwk_ObjFaninNum(pNode) );
    for ( i = 1; i < Nwk_ObjFaninNum(pNode); i++ )
    {
        assert( pPinPerm[i] < Nwk_ObjFaninNum(pNode) );
        assert( pPinDelays[pPinPerm[i-1]] >= pPinDelays[pPinPerm[i]] );
    }
}

ABC_DLL void Nwk_ManDeleteNode

(

Nwk_Obj_t *

pObj

)

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

Synopsis [Deletes the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 155 of file nwkObj.c.

{
    Vec_Ptr_t * vNodes = pObj->pMan->vTemp;
    Nwk_Obj_t * pTemp;
    int i;
    assert( Nwk_ObjFanoutNum(pObj) == 0 );
    // delete fanins
    Nwk_ObjCollectFanins( pObj, vNodes );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vNodes, pTemp, i )
        Nwk_ObjDeleteFanin( pObj, pTemp );
    // remove from the list of objects
    Vec_PtrWriteEntry( pObj->pMan->vObjs, pObj->Id, NULL );
    pObj->pMan->nObjs[pObj->Type]--;
    memset( pObj, 0, sizeof(Nwk_Obj_t) );
    pObj->Id = -1;
}

ABC_DLL void Nwk_ManDeleteNode_rec

(

Nwk_Obj_t *

pObj

)

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

Synopsis [Deletes the node and MFFC of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 183 of file nwkObj.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    assert( !Nwk_ObjIsCi(pObj) );
    assert( Nwk_ObjFanoutNum(pObj) == 0 );
    vNodes = Vec_PtrAlloc( 100 );
    Nwk_ObjCollectFanins( pObj, vNodes );
    Nwk_ManDeleteNode( pObj );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vNodes, pObj, i )
        if ( Nwk_ObjIsNode(pObj) && Nwk_ObjFanoutNum(pObj) == 0 )
            Nwk_ManDeleteNode_rec( pObj );
    Vec_PtrFree( vNodes );
}

ABC_DLL Vec_Ptr_t* Nwk_ManDeriveRetimingCut	(	Aig_Man_t *	p,
		int	fForward,
		int	fVerbose
	)

FUNCTION DECLARATIONS ///.

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

Synopsis [Converts AIG into the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 85 of file nwkAig.c.

{ 
    Vec_Ptr_t * vNodes;
    Nwk_Man_t * pNtk;
    Nwk_Obj_t * pNode;
    Aig_Obj_t * pObj;
    int i;
    pNtk = Nwk_ManDeriveFromAig( p );
    if ( fForward )
        vNodes = Nwk_ManRetimeCutForward( pNtk, Aig_ManRegNum(p), fVerbose );
    else
        vNodes = Nwk_ManRetimeCutBackward( pNtk, Aig_ManRegNum(p), fVerbose );
    Aig_ManForEachObj( p, pObj, i )
        ((Nwk_Obj_t *)pObj->pData)->pCopy = pObj;
    Vec_PtrForEachEntry( Nwk_Obj_t *, vNodes, pNode, i )
        Vec_PtrWriteEntry( vNodes, i, pNode->pCopy );
    Nwk_ManFree( pNtk );
//    assert( Vec_PtrSize(vNodes) <= Aig_ManRegNum(p) );
    return vNodes;
}

ABC_DLL Vec_Ptr_t* Nwk_ManDfs

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Returns the DFS ordered array of all objects except latches.]

Description []

SideEffects []

SeeAlso []

Definition at line 321 of file nwkDfs.c.

{
    Vec_Ptr_t * vNodes;
    Nwk_Obj_t * pObj;
    int i;
    Nwk_ManIncrementTravId( pNtk );
    vNodes = Vec_PtrAlloc( 100 );
    Nwk_ManForEachObj( pNtk, pObj, i )
    {
        if ( Nwk_ObjIsCi(pObj) )
        {
            Nwk_ObjSetTravIdCurrent( pObj );
            Vec_PtrPush( vNodes, pObj );
        }
        else if ( Nwk_ObjIsCo(pObj) )
            Nwk_ManDfs_rec( pObj, vNodes );
    }
    return vNodes;
}

ABC_DLL Vec_Ptr_t* Nwk_ManDfsNodes	(	Nwk_Man_t *	pNtk,
		Nwk_Obj_t **	ppNodes,
		int	nNodes
	)

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

Synopsis [Returns the set of internal nodes rooted in the given nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 378 of file nwkDfs.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    // set the traversal ID
    Nwk_ManIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // go through the PO nodes and call for each of them
    for ( i = 0; i < nNodes; i++ )
        if ( Nwk_ObjIsCo(ppNodes[i]) )
            Nwk_ManDfsNodes_rec( Nwk_ObjFanin0(ppNodes[i]), vNodes );
        else
            Nwk_ManDfsNodes_rec( ppNodes[i], vNodes );
    return vNodes;
}

ABC_DLL Vec_Ptr_t* Nwk_ManDfsReverse

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Returns the DFS ordered array of all objects except latches.]

Description []

SideEffects []

SeeAlso []

Definition at line 451 of file nwkDfs.c.

{
    Vec_Ptr_t * vNodes;
    Nwk_Obj_t * pObj;
    int i;
    Nwk_ManIncrementTravId( pNtk );
    vNodes = Vec_PtrAlloc( 100 );
    Nwk_ManForEachPi( pNtk, pObj, i )
        Nwk_ManDfsReverse_rec( pObj, vNodes );
    // add nodes without fanins
    Nwk_ManForEachNode( pNtk, pObj, i )
        if ( Nwk_ObjFaninNum(pObj) == 0 && !Nwk_ObjIsTravIdCurrent(pObj) )
            Vec_PtrPush( vNodes, pObj );
    return vNodes;
}

ABC_DLL void Nwk_ManDumpBlif	(	Nwk_Man_t *	pNtk,
		char *	pFileName,
		Vec_Ptr_t *	vPiNames,
		Vec_Ptr_t *	vPoNames
	)

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

Synopsis [Dumps the BLIF file for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 257 of file nwkUtil.c.

{
    FILE * pFile;
    Vec_Ptr_t * vNodes;
    Vec_Int_t * vTruth;
    Vec_Int_t * vCover;
    Nwk_Obj_t * pObj, * pFanin;
    Aig_MmFlex_t * pMem;
    char * pSop = NULL;
    unsigned * pTruth;
    int i, k, nDigits;
    if ( Nwk_ManPoNum(pNtk) == 0 )
    {
        printf( "Nwk_ManDumpBlif(): Network does not have POs.\n" );
        return;
    }
    // collect nodes in the DFS order
    nDigits = Abc_Base10Log( Nwk_ManObjNumMax(pNtk) );
    // write the file 
    pFile = fopen( pFileName, "w" );
    fprintf( pFile, "# BLIF file written by procedure Nwk_ManDumpBlif()\n" );
//    fprintf( pFile, "# http://www.eecs.berkeley.edu/~alanmi/abc/\n" );
    fprintf( pFile, ".model %s\n", pNtk->pName );
    // write PIs
    fprintf( pFile, ".inputs" );
    Nwk_ManForEachCi( pNtk, pObj, i )
        if ( vPiNames )
            fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, i) );
        else
            fprintf( pFile, " n%0*d", nDigits, pObj->Id );
    fprintf( pFile, "\n" );
    // write POs
    fprintf( pFile, ".outputs" );
    Nwk_ManForEachCo( pNtk, pObj, i )
        if ( vPoNames )
            fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPoNames, i) );
        else
            fprintf( pFile, " n%0*d", nDigits, pObj->Id );
    fprintf( pFile, "\n" );
    // write nodes
    pMem = Aig_MmFlexStart();
    vTruth = Vec_IntAlloc( 1 << 16 );
    vCover = Vec_IntAlloc( 1 << 16 );
    vNodes = Nwk_ManDfs( pNtk );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vNodes, pObj, i )
    {
        if ( !Nwk_ObjIsNode(pObj) )
            continue;
        // derive SOP for the AIG
        pTruth = Hop_ManConvertAigToTruth( pNtk->pManHop, Hop_Regular(pObj->pFunc), Nwk_ObjFaninNum(pObj), vTruth, 0 );
        if ( Hop_IsComplement(pObj->pFunc) )
            Kit_TruthNot( pTruth, pTruth, Nwk_ObjFaninNum(pObj) );
        pSop = Kit_PlaFromTruth( pMem, pTruth, Nwk_ObjFaninNum(pObj), vCover );
        // write the node
        fprintf( pFile, ".names" );
        if ( !Kit_TruthIsConst0(pTruth, Nwk_ObjFaninNum(pObj)) && !Kit_TruthIsConst1(pTruth, Nwk_ObjFaninNum(pObj)) )
        {
            Nwk_ObjForEachFanin( pObj, pFanin, k )
                if ( vPiNames && Nwk_ObjIsPi(pFanin) )
                    fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Nwk_ObjPioNum(pFanin)) );
                else
                    fprintf( pFile, " n%0*d", nDigits, pFanin->Id );
        }
        fprintf( pFile, " n%0*d\n", nDigits, pObj->Id );
        // write the function
        fprintf( pFile, "%s", pSop );
    }
    Vec_IntFree( vCover );
    Vec_IntFree( vTruth );
    Vec_PtrFree( vNodes );
    Aig_MmFlexStop( pMem, 0 );
    // write POs
    Nwk_ManForEachCo( pNtk, pObj, i )
    {
        fprintf( pFile, ".names" );
        if ( vPiNames && Nwk_ObjIsPi(Nwk_ObjFanin0(pObj)) )
            fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Nwk_ObjPioNum(Nwk_ObjFanin0(pObj))) );
        else
            fprintf( pFile, " n%0*d", nDigits, Nwk_ObjFanin0(pObj)->Id );
        if ( vPoNames )
            fprintf( pFile, " %s\n", (char*)Vec_PtrEntry(vPoNames, Nwk_ObjPioNum(pObj)) );
        else
            fprintf( pFile, " n%0*d\n", nDigits, pObj->Id );
        fprintf( pFile, "%d 1\n", !pObj->fInvert );
    }
    fprintf( pFile, ".end\n\n" );
    fclose( pFile );
}

ABC_DLL void Nwk_ManFree

(

Nwk_Man_t *

p

)

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

Synopsis [Deallocates the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file nwkMan.c.

{
//    printf( "The number of realloced nodes = %d.\n", p->nRealloced );
    if ( p->pName )    ABC_FREE( p->pName );
    if ( p->pSpec )    ABC_FREE( p->pSpec );
    if ( p->vCis )     Vec_PtrFree( p->vCis );
    if ( p->vCos )     Vec_PtrFree( p->vCos );
    if ( p->vObjs )    Vec_PtrFree( p->vObjs );
    if ( p->vTemp )    Vec_PtrFree( p->vTemp );
    if ( p->pManTime ) Tim_ManStop( p->pManTime );
    if ( p->pMemObjs ) Aig_MmFlexStop( p->pMemObjs, 0 );
    if ( p->pManHop )  Hop_ManStop( p->pManHop );
    ABC_FREE( p );
}

ABC_DLL int Nwk_ManGetAigNodeNum

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Reads the number of AIG nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 155 of file nwkUtil.c.

{
    Nwk_Obj_t * pNode;
    int i, nNodes = 0;
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( pNode->pFunc == NULL )
        {
            printf( "Nwk_ManGetAigNodeNum(): Local AIG of node %d is not assigned.\n", pNode->Id );
            continue;
        }
        if ( Nwk_ObjFaninNum(pNode) < 2 )
            continue;
        nNodes += Hop_DagSize( pNode->pFunc );
    }
    return nNodes;
}

ABC_DLL int Nwk_ManGetFaninMax

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Reads the maximum number of fanins of a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file nwkUtil.c.

{
    Nwk_Obj_t * pNode;
    int i, nFaninsMax = 0;
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( nFaninsMax < Nwk_ObjFaninNum(pNode) )
            nFaninsMax = Nwk_ObjFaninNum(pNode);
    }
    return nFaninsMax;
}

ABC_DLL int Nwk_ManGetTotalFanins

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Reads the total number of all fanins.]

Description []

SideEffects []

SeeAlso []

Definition at line 94 of file nwkUtil.c.

{
    Nwk_Obj_t * pNode;
    int i, nFanins = 0;
    Nwk_ManForEachNode( pNtk, pNode, i )
        nFanins += Nwk_ObjFaninNum(pNode);
    return nFanins;
}

ABC_DLL void Nwk_ManIncrementTravId

(

Nwk_Man_t *

pNtk

)

DECLARATIONS ///.

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

FileName [nwkUtil.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [Various utilities.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

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

Synopsis [Increments the current traversal ID of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file nwkUtil.c.

{
    Nwk_Obj_t * pObj;
    int i;
    if ( pNtk->nTravIds >= (1<<26)-1 )
    {
        pNtk->nTravIds = 0;
        Nwk_ManForEachObj( pNtk, pObj, i )
            pObj->TravId = 0;
    }
    pNtk->nTravIds++;
}

static int Nwk_ManLatchNum ( Nwk_Man_t *  p )

inlinestatic

Definition at line 128 of file nwk.h.

{ return p->nObjs[NWK_OBJ_LATCH];             } 

ABC_DLL int Nwk_ManLevel

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description [Does not assume that the objects are in a topo order.]

SideEffects []

SeeAlso []

Definition at line 215 of file nwkDfs.c.

{
    Nwk_Obj_t * pObj;
    int i, LevelMax = 0;
    Nwk_ManForEachObj( pNtk, pObj, i )
        Nwk_ObjSetLevel( pObj, 0 );
    Nwk_ManIncrementTravId( pNtk );
    Nwk_ManForEachPo( pNtk, pObj, i )
    {
        Nwk_ManLevel_rec( pObj );
        if ( LevelMax < Nwk_ObjLevel(pObj) )
            LevelMax = Nwk_ObjLevel(pObj);
    }
    Nwk_ManForEachCi( pNtk, pObj, i )
    {
        Nwk_ManLevel_rec( pObj );
        if ( LevelMax < Nwk_ObjLevel(pObj) )
            LevelMax = Nwk_ObjLevel(pObj);
    }
    return LevelMax;
}

ABC_DLL int Nwk_ManLevelBackup

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description [Assumes that white boxes have unit level.]

SideEffects []

SeeAlso []

Definition at line 102 of file nwkDfs.c.

{
    Tim_Man_t * pManTimeUnit;
    Nwk_Obj_t * pObj, * pFanin;
    int i, k, LevelMax, Level;
    assert( Nwk_ManVerifyTopoOrder(pNtk) );
    // clean the levels
    Nwk_ManForEachObj( pNtk, pObj, i )
        Nwk_ObjSetLevel( pObj, 0 );
    // perform level computation
    LevelMax = 0;
    pManTimeUnit = pNtk->pManTime ? Tim_ManDup( pNtk->pManTime, 1 ) : NULL;
    if ( pManTimeUnit )
        Tim_ManIncrementTravId( pManTimeUnit );
    Nwk_ManForEachObj( pNtk, pObj, i )
    {
        if ( Nwk_ObjIsCi(pObj) )
        {
            Level = pManTimeUnit? (int)Tim_ManGetCiArrival( pManTimeUnit, pObj->PioId ) : 0;
            Nwk_ObjSetLevel( pObj, Level );
        }
        else if ( Nwk_ObjIsCo(pObj) )
        {
            Level = Nwk_ObjLevel( Nwk_ObjFanin0(pObj) );
            if ( pManTimeUnit )
                Tim_ManSetCoArrival( pManTimeUnit, pObj->PioId, (float)Level );
            Nwk_ObjSetLevel( pObj, Level );
            if ( LevelMax < Nwk_ObjLevel(pObj) )
                LevelMax = Nwk_ObjLevel(pObj);
        }
        else if ( Nwk_ObjIsNode(pObj) )
        {
            Level = 0;
            Nwk_ObjForEachFanin( pObj, pFanin, k )
                if ( Level < Nwk_ObjLevel(pFanin) )
                    Level = Nwk_ObjLevel(pFanin);
            Nwk_ObjSetLevel( pObj, Level + 1 );
        }
        else
            assert( 0 );
    }
    // set the old timing manager
    if ( pManTimeUnit )
        Tim_ManStop( pManTimeUnit );
    return LevelMax;
}

ABC_DLL Vec_Vec_t* Nwk_ManLevelize

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Returns the array of objects in the AIG manager ordered by level.]

Description []

SideEffects []

SeeAlso []

Definition at line 269 of file nwkDfs.c.

{
    Nwk_Obj_t * pObj;
    Vec_Vec_t * vLevels;
    int nLevels, i;
    assert( Nwk_ManVerifyLevel(pNtk) );
    nLevels = Nwk_ManLevelMax( pNtk );
    vLevels = Vec_VecStart( nLevels + 1 );
    Nwk_ManForEachNode( pNtk, pObj, i )
    {
        assert( Nwk_ObjLevel(pObj) <= nLevels );
        Vec_VecPush( vLevels, Nwk_ObjLevel(pObj), pObj );
    }
    return vLevels;
}

ABC_DLL int Nwk_ManLevelMax

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description [Does not assume that the objects are in a topo order.]

SideEffects []

SeeAlso []

Definition at line 248 of file nwkDfs.c.

{
    Nwk_Obj_t * pObj;
    int i, LevelMax = 0;
    Nwk_ManForEachPo( pNtk, pObj, i )
        if ( LevelMax < Nwk_ObjLevel(pObj) )
            LevelMax = Nwk_ObjLevel(pObj);
    return LevelMax;
}

ABC_DLL void Nwk_ManMinimumBase	(	Nwk_Man_t *	pNtk,
		int	fVerbose
	)

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

Synopsis [Minimizes the support of all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 563 of file nwkUtil.c.

{
    Vec_Int_t * vTruth;
    Nwk_Obj_t * pObj;
    int i, Counter = 0;
    vTruth = Vec_IntAlloc( 1 << 16 );
    Nwk_ManForEachNode( pNtk, pObj, i )
        Counter += Nwk_ManMinimumBaseNode( pObj, vTruth, fVerbose );
    if ( fVerbose && Counter )
        printf( "Support minimization reduced support of %d nodes.\n", Counter );
    Vec_IntFree( vTruth );
}

static int Nwk_ManNodeNum ( Nwk_Man_t *  p )

inlinestatic

Definition at line 127 of file nwk.h.

{ return p->nObjs[NWK_OBJ_NODE];              } 

static Nwk_Obj_t* Nwk_ManObj ( Nwk_Man_t *  p, int  i  )

inlinestatic

Definition at line 133 of file nwk.h.

{ return (Nwk_Obj_t *)Vec_PtrEntry( p->vObjs, i );         } 

static int Nwk_ManObjNumMax ( Nwk_Man_t *  p )

inlinestatic

Definition at line 129 of file nwk.h.

{ return Vec_PtrSize(p->vObjs);               }

ABC_DLL int Nwk_ManPiNum

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Returns the number of true PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 115 of file nwkUtil.c.

{
    Nwk_Obj_t * pNode;
    int i, Counter = 0;
    Nwk_ManForEachCi( pNtk, pNode, i )
        Counter += Nwk_ObjIsPi( pNode );
    return Counter;
}

ABC_DLL int Nwk_ManPoNum

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Returns the number of true POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 135 of file nwkUtil.c.

{
    Nwk_Obj_t * pNode;
    int i, Counter = 0;
    Nwk_ManForEachCo( pNtk, pNode, i )
        Counter += Nwk_ObjIsPo( pNode );
    return Counter;
}

ABC_DLL void Nwk_ManPrintFanioNew

(

Nwk_Man_t *

pNtk

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 357 of file nwkUtil.c.

{
    char Buffer[100];
    Nwk_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;
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        nFanins  = Nwk_ObjFaninNum(pNode);
        nFanouts = Nwk_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
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        nFanins  = Nwk_ObjFaninNum(pNode);
        nFanouts = Nwk_ObjFanoutNum(pNode);
//        nFanouts = Nwk_NodeMffcSize(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 );
    }

    printf( "The distribution of fanins and fanouts in the network:\n" );
    printf( "         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 )
            printf( "%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 ); 
            printf( "%15s : ", Buffer );
        }
        if ( vFanins->pArray[k] == 0 )
            printf( "              " );
        else
            printf( "%12d  ", vFanins->pArray[k] );
        printf( "    " );
        if ( vFanouts->pArray[k] == 0 )
            printf( "              " );
        else
            printf( "%12d  ", vFanouts->pArray[k] );
        printf( "\n" );
    }
    Vec_IntFree( vFanins );
    Vec_IntFree( vFanouts );

    printf( "Fanins: Max = %d. Ave = %.2f.  Fanouts: Max = %d. Ave =  %.2f.\n", 
        nFaninsMax,  1.0*nFaninsAll/Nwk_ManNodeNum(pNtk), 
        nFanoutsMax, 1.0*nFanoutsAll/Nwk_ManNodeNum(pNtk)  );
}

ABC_DLL void Nwk_ManPrintStats	(	Nwk_Man_t *	pNtk,
		If_LibLut_t *	pLutLib,
		int	fSaveBest,
		int	fDumpResult,
		int	fPower,
		Ntl_Man_t *	pNtl
	)

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

Synopsis [Prints stats of the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 234 of file nwkMan.c.

{
//    extern int Ntl_ManLatchNum( Ntl_Man_t * p );
//    extern void Ntl_ManWriteBlifLogic( Nwk_Man_t * pNtk, void * pNtl, char * pFileName );
    if ( fSaveBest )
        Nwk_ManCompareAndSaveBest( pNtk, pNtl );
    if ( fDumpResult )
    {
        char Buffer[1000] = {0};
        const char * pNameGen = pNtk->pSpec? Nwk_FileNameGeneric( pNtk->pSpec ) : "nameless_";
        sprintf( Buffer, "%s_dump.blif", pNameGen );
//        Ntl_ManWriteBlifLogic( pNtk, pNtl, Buffer );
//        sprintf( Buffer, "%s_dump_map.blif", pNameGen );
//        Nwk_ManDumpBlif( pNtk, Buffer, NULL, NULL );
        if ( pNtk->pSpec ) ABC_FREE( pNameGen );
    }

    pNtk->pLutLib = pLutLib;
    printf( "%-15s : ",      pNtk->pName );
    printf( "pi = %5d  ",    Nwk_ManPiNum(pNtk) );
    printf( "po = %5d  ",    Nwk_ManPoNum(pNtk) );
    printf( "ci = %5d  ",    Nwk_ManCiNum(pNtk) );
    printf( "co = %5d  ",    Nwk_ManCoNum(pNtk) );
//    printf( "lat = %5d  ",   Ntl_ManLatchNum(pNtl) );
    printf( "node = %5d  ",  Nwk_ManNodeNum(pNtk) );
    printf( "edge = %5d  ",  Nwk_ManGetTotalFanins(pNtk) );
    printf( "aig = %6d  ",   Nwk_ManGetAigNodeNum(pNtk) );
    printf( "lev = %3d  ",   Nwk_ManLevel(pNtk) );
//    printf( "lev2 = %3d  ",  Nwk_ManLevelBackup(pNtk) );
    printf( "delay = %5.2f  ", Nwk_ManDelayTraceLut(pNtk) );
    if ( fPower )
        printf( "power = %7.2f   ", Nwl_ManComputeTotalSwitching(pNtk) );
    Nwk_ManPrintLutSizes( pNtk, pLutLib );
    printf( "\n" );
//    Nwk_ManDelayTracePrint( pNtk, pLutLib );
    fflush( stdout );
}

ABC_DLL void Nwk_ManRemoveDupFanins	(	Nwk_Man_t *	pNtk,
		int	fVerbose
	)

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

Synopsis [Minimizes the support of all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 608 of file nwkUtil.c.

{
    Vec_Int_t * vTruth;
    Nwk_Obj_t * pObj;
    int i, k, m, fFound;
    // check if the nodes have duplicated fanins
    vTruth = Vec_IntAlloc( 1 << 16 );
    Nwk_ManForEachNode( pNtk, pObj, i )
    {
        fFound = 0;
        for ( k = 0; k < pObj->nFanins; k++ )
        {
            for ( m = k + 1; m < pObj->nFanins; m++ )
                if ( pObj->pFanio[k] == pObj->pFanio[m] )
                {
                    if ( fVerbose )
                        printf( "Removing duplicated fanins of node %d (fanins %d and %d).\n", 
                            pObj->Id, pObj->pFanio[k]->Id, pObj->pFanio[m]->Id );
                    Nwk_ManRemoveDupFaninsNode( pObj, k, m, vTruth );
                    fFound = 1;
                    break;
                }
            if ( fFound )
                break;
        }
    }
    Vec_IntFree( vTruth );
//    Nwk_ManMinimumBase( pNtk, fVerbose );
}

ABC_DLL Vec_Ptr_t* Nwk_ManRetimeCutBackward	(	Nwk_Man_t *	pMan,
		int	nLatches,
		int	fVerbose
	)

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

Synopsis [Computes minimum cut for backward retiming.]

Description []

SideEffects []

SeeAlso []

Definition at line 523 of file nwkFlow.c.

{
    Vec_Ptr_t * vNodes;
    Nwk_Obj_t * pObj;
    int i, RetValue, Counter = 0, Counter2 = 0;
    abctime clk = Abc_Clock();
    // set the sequential parameters
    pMan->nLatches = nLatches;
    pMan->nTruePis = Nwk_ManCiNum(pMan) - nLatches;
    pMan->nTruePos = Nwk_ManCoNum(pMan) - nLatches;
    // mark the CIs, the TFI of POs, and the constant nodes
    Nwk_ManForEachCi( pMan, pObj, i )
        pObj->MarkA = 1;
    Nwk_ManForEachPoSeq( pMan, pObj, i )
        Nwk_ManMarkTfiCone_rec( pObj );
    Nwk_ManForEachNode( pMan, pObj, i )
        if ( Nwk_ObjFaninNum(pObj) == 0 )
            pObj->MarkA = 1;
    // start flow computation from each LI driver
    Nwk_ManIncrementTravIdFlow( pMan );
    Nwk_ManForEachLiSeq( pMan, pObj, i )
    {
        if ( !Nwk_ManPushBackwardFast_rec( Nwk_ObjFanin0(pObj), NULL ) )
            continue;
        Nwk_ManIncrementTravIdFlow( pMan );
        Counter++; 
    }
    if ( fVerbose ) 
    printf( "Backward: Max-flow = %4d -> ", Counter );
    // continue flow computation from each LI driver
    Nwk_ManIncrementTravIdFlow( pMan );
    Nwk_ManForEachLiSeq( pMan, pObj, i )
    {
        if ( !Nwk_ManPushBackwardBot_rec( Nwk_ObjFanin0(pObj), NULL ) )
            continue;
        Nwk_ManIncrementTravIdFlow( pMan );
        Counter2++;
    }
    if ( fVerbose )
    printf( "%4d.  ", Counter+Counter2 );
    // repeat flow computation from each LI driver
    if ( Counter2 > 0 )
    {
        Nwk_ManIncrementTravIdFlow( pMan );
        Nwk_ManForEachLiSeq( pMan, pObj, i )
        {
            RetValue = Nwk_ManPushBackwardBot_rec( Nwk_ObjFanin0(pObj), NULL );
            assert( !RetValue );
        }
    }
    // cut is a set of nodes whose bottom is visited but top is not visited
    vNodes = Vec_PtrAlloc( Counter+Counter2 );
    Nwk_ManForEachObj( pMan, pObj, i )
    {
        if ( Nwk_ObjVisitedBotOnly(pObj) )
        {
            assert( Nwk_ObjHasFlow(pObj) );
            assert( !Nwk_ObjIsCo(pObj) );
            Vec_PtrPush( vNodes, pObj );
        }
    }
    // count CO drivers
    Counter = 0;
    Nwk_ManForEachLiSeq( pMan, pObj, i )
        if ( Nwk_ObjVisitedBotOnly( Nwk_ObjFanin0(pObj) ) )
            Counter++;
    Nwk_ManCleanMarks( pMan );
//    assert( Nwk_ManRetimeVerifyCutBackward(pMan, vNodes) );
    if ( fVerbose )
    {
    printf( "Min-cut = %4d.  Unmoved = %4d. ", Vec_PtrSize(vNodes), Counter );
    ABC_PRT( "Time", Abc_Clock() - clk );
    }
    return vNodes;
}

ABC_DLL Vec_Ptr_t* Nwk_ManRetimeCutForward	(	Nwk_Man_t *	pMan,
		int	nLatches,
		int	fVerbose
	)

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

Synopsis [Computes minimum cut for forward retiming.]

Description []

SideEffects []

SeeAlso []

Definition at line 442 of file nwkFlow.c.

{
    Vec_Ptr_t * vNodes;
    Nwk_Obj_t * pObj;
    int i, RetValue, Counter = 0, Counter2 = 0;
    abctime clk = Abc_Clock();
    // set the sequential parameters
    pMan->nLatches = nLatches;
    pMan->nTruePis = Nwk_ManCiNum(pMan) - nLatches;
    pMan->nTruePos = Nwk_ManCoNum(pMan) - nLatches;
    // mark the COs and the TFO of PIs
    Nwk_ManForEachCo( pMan, pObj, i )
        pObj->MarkA = 1;
    Nwk_ManForEachPiSeq( pMan, pObj, i )
        Nwk_ManMarkTfoCone_rec( pObj );
    // start flow computation from each LO
    Nwk_ManIncrementTravIdFlow( pMan );
    Nwk_ManForEachLoSeq( pMan, pObj, i )
    {
        if ( !Nwk_ManPushForwardFast_rec( pObj, NULL ) )
            continue;
        Nwk_ManIncrementTravIdFlow( pMan );
        Counter++;
    }
    if ( fVerbose )
    printf( "Forward:  Max-flow = %4d -> ", Counter );
    // continue flow computation from each LO
    Nwk_ManIncrementTravIdFlow( pMan );
    Nwk_ManForEachLoSeq( pMan, pObj, i )
    {
        if ( !Nwk_ManPushForwardBot_rec( pObj, NULL ) )
            continue;
        Nwk_ManIncrementTravIdFlow( pMan );
        Counter2++;
    }
    if ( fVerbose )
    printf( "%4d.  ", Counter+Counter2 );
    // repeat flow computation from each LO
    if ( Counter2 > 0 )
    {
        Nwk_ManIncrementTravIdFlow( pMan );
        Nwk_ManForEachLoSeq( pMan, pObj, i )
        {
            RetValue = Nwk_ManPushForwardBot_rec( pObj, NULL );
            assert( !RetValue );
        }
    }
    // cut is a set of nodes whose bottom is visited but top is not visited
    vNodes = Vec_PtrAlloc( Counter+Counter2 );
    Counter = 0;
    Nwk_ManForEachObj( pMan, pObj, i )
    {
        if ( Nwk_ObjVisitedBotOnly(pObj) )
        {
            assert( Nwk_ObjHasFlow(pObj) );
            assert( !Nwk_ObjIsCo(pObj) );
            Vec_PtrPush( vNodes, pObj );
            Counter += Nwk_ObjIsCi(pObj);
        }
    }
    Nwk_ManCleanMarks( pMan );
//    assert( Nwk_ManRetimeVerifyCutForward(pMan, vNodes) );
    if ( fVerbose )
    {
    printf( "Min-cut = %4d.  Unmoved = %4d. ", Vec_PtrSize(vNodes), Counter );
    ABC_PRT( "Time", Abc_Clock() - clk );
    }
    return vNodes;
}

ABC_DLL Aig_Man_t* Nwk_ManSpeedup	(	Nwk_Man_t *	pNtk,
		int	fUseLutLib,
		int	Percentage,
		int	Degree,
		int	fVerbose,
		int	fVeryVerbose
	)

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

Synopsis [Adds choices to speed up the network by the given percentage.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file nwkSpeedup.c.

{
    Aig_Man_t * pAig, * pTemp;
    Vec_Ptr_t * vTimeCries, * vTimeFanins;
    Nwk_Obj_t * pNode, * pFanin, * pFanin2;
    Aig_Obj_t * pAnd;
    If_LibLut_t * pTempLib = pNtk->pLutLib;
    Tim_Man_t * pTempTim = NULL; 
    float tDelta, tArrival;
    int i, k, k2, Counter, CounterRes, nTimeCris;
    unsigned * puTCEdges;
    // perform delay trace
    if ( !fUseLutLib )
    {
        pNtk->pLutLib = NULL;
        if ( pNtk->pManTime )
        {
            pTempTim = pNtk->pManTime;
            pNtk->pManTime = Tim_ManDup( pTempTim, 1 );
        }
    }
    tArrival = Nwk_ManDelayTraceLut( pNtk );
    tDelta = fUseLutLib ? tArrival*Percentage/100.0 : 1.0;
    if ( fVerbose )
    {
        printf( "Max delay = %.2f. Delta = %.2f. ", tArrival, tDelta );
        printf( "Using %s model. ", fUseLutLib? "LUT library" : "unit-delay" );
        if ( fUseLutLib )
            printf( "Percentage = %d. ", Percentage );
        printf( "\n" );
    }
    // mark the timing critical nodes and edges
    puTCEdges = ABC_ALLOC( unsigned, Nwk_ManObjNumMax(pNtk) );
    memset( puTCEdges, 0, sizeof(unsigned) * Nwk_ManObjNumMax(pNtk) );
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( Nwk_ObjSlack(pNode) >= tDelta )
            continue;
        puTCEdges[pNode->Id] = Nwk_ManDelayTraceTCEdges( pNtk, pNode, tDelta, fUseLutLib );
    }
    if ( fVerbose )
    {
        Counter = CounterRes = 0;
        Nwk_ManForEachNode( pNtk, pNode, i )
        {
            Nwk_ObjForEachFanin( pNode, pFanin, k )
                if ( !Nwk_ObjIsCi(pFanin) && Nwk_ObjSlack(pFanin) < tDelta )
                    Counter++;
            CounterRes += Aig_WordCountOnes( puTCEdges[pNode->Id] );
        }
        printf( "Edges: Total = %7d. 0-slack = %7d. Critical = %7d. Ratio = %4.2f\n", 
            Nwk_ManGetTotalFanins(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
    }
    // start the resulting network
    pAig = Nwk_ManStrash( pNtk );
    pAig->pEquivs = ABC_ALLOC( Aig_Obj_t *, 3 * Aig_ManObjNumMax(pAig) );
    memset( pAig->pEquivs, 0, sizeof(Aig_Obj_t *) * 3 * Aig_ManObjNumMax(pAig) );

    // collect nodes to be used for resynthesis
    Counter = CounterRes = 0;
    vTimeCries = Vec_PtrAlloc( 16 );
    vTimeFanins = Vec_PtrAlloc( 16 );
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( Nwk_ObjSlack(pNode) >= tDelta )
            continue;
        // count the number of non-PI timing-critical nodes
        nTimeCris = 0;
        Nwk_ObjForEachFanin( pNode, pFanin, k )
            if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
                nTimeCris++;
        if ( !fVeryVerbose && nTimeCris == 0 )
            continue;
        Counter++;
        // count the total number of timing critical second-generation nodes
        Vec_PtrClear( vTimeCries );
        if ( nTimeCris )
        {
            Nwk_ObjForEachFanin( pNode, pFanin, k )
                if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
                    Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
                        if ( puTCEdges[pFanin->Id] & (1<<k2) )
                            Vec_PtrPushUnique( vTimeCries, pFanin2 );
        }
//        if ( !fVeryVerbose && (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
        if ( (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
            continue;
        CounterRes++;
        // collect second generation nodes
        Vec_PtrClear( vTimeFanins );
        Nwk_ObjForEachFanin( pNode, pFanin, k )
        {
            if ( Nwk_ObjIsCi(pFanin) )
                Vec_PtrPushUnique( vTimeFanins, pFanin );
            else
                Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
                    Vec_PtrPushUnique( vTimeFanins, pFanin2 );                    
        }
        // print the results
        if ( fVeryVerbose )
        {
        printf( "%5d Node %5d : %d %2d %2d  ", Counter, pNode->Id, 
            nTimeCris, Vec_PtrSize(vTimeCries), Vec_PtrSize(vTimeFanins) );
        Nwk_ObjForEachFanin( pNode, pFanin, k )
            printf( "%d(%.2f)%s ", pFanin->Id, Nwk_ObjSlack(pFanin), (puTCEdges[pNode->Id] & (1<<k))? "*":"" );
        printf( "\n" );
        }
        // add the node to choices
        if ( Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree )
            continue;
        // order the fanins in the increasing order of criticalily
        if ( Vec_PtrSize(vTimeCries) > 1 )
        {
            pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 0 );
            pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
            if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
            {
                Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
                Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
            }
        }
        if ( Vec_PtrSize(vTimeCries) > 2 )
        {
            pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
            pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 2 );
            if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
            {
                Vec_PtrWriteEntry( vTimeCries, 1, pFanin2 );
                Vec_PtrWriteEntry( vTimeCries, 2, pFanin );
            }
            pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 0 );
            pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
            if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
            {
                Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
                Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
            }
        }
        // add choice
        Aig_ManSpeedupNode( pNtk, pAig, pNode, vTimeFanins, vTimeCries );
    }
    Vec_PtrFree( vTimeCries );
    Vec_PtrFree( vTimeFanins );
    ABC_FREE( puTCEdges );
    if ( fVerbose )
        printf( "Nodes: Total = %7d. 0-slack = %7d. Workable = %7d. Ratio = %4.2f\n", 
        Nwk_ManNodeNum(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 ); 

    // remove invalid choice nodes
    Aig_ManForEachNode( pAig, pAnd, i )
        if ( Aig_ObjEquiv(pAig, pAnd) )
        {
            if ( Aig_ObjRefs(Aig_ObjEquiv(pAig, pAnd)) > 0 )
                pAig->pEquivs[pAnd->Id] = NULL;
        }

    // put back the library
    if ( !fUseLutLib )
        pNtk->pLutLib = pTempLib;
    if ( pTempTim )
    {
        Tim_ManStop( pNtk->pManTime );
        pNtk->pManTime = pTempTim;
    }

    // reconstruct the network
    pAig = Aig_ManDupDfs( pTemp = pAig );
    Aig_ManStop( pTemp );
    // reset levels
    Aig_ManChoiceLevel( pAig );
    return pAig;
}

ABC_DLL Aig_Man_t* Nwk_ManStrash

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Derives AIG from the logic network.]

Description [Assumes topological ordering of nodes.]

SideEffects []

SeeAlso []

Definition at line 99 of file nwkStrash.c.

{
    Vec_Ptr_t * vObjs;
    Aig_Man_t * pMan;
    Aig_Obj_t * pObjNew;
    Nwk_Obj_t * pObj;
    int i, Level;
    pMan = Aig_ManStart( Nwk_ManGetAigNodeNum(pNtk) );
    pMan->pName = Abc_UtilStrsav( pNtk->pName );
    pMan->pSpec = Abc_UtilStrsav( pNtk->pSpec );
    pMan->pManTime = Tim_ManDup( (Tim_Man_t *)pNtk->pManTime, 1 );
    Tim_ManIncrementTravId( (Tim_Man_t *)pMan->pManTime );
    Nwk_ManForEachObj( pNtk, pObj, i )
        pObj->pCopy = NULL;
//    Nwk_ManForEachObj( pNtk, pObj, i )
    vObjs = Nwk_ManDfs( pNtk );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vObjs, pObj, i )
    {
        if ( Nwk_ObjIsCi(pObj) )
        {
            pObjNew = Aig_ObjCreateCi(pMan);
            Level = Tim_ManGetCiArrival( (Tim_Man_t *)pMan->pManTime, pObj->PioId );
            Aig_ObjSetLevel( pObjNew, Level );
        }
        else if ( Nwk_ObjIsCo(pObj) )
        {
            pObjNew = Aig_ObjCreateCo( pMan, Aig_NotCond((Aig_Obj_t *)Nwk_ObjFanin0(pObj)->pCopy, pObj->fInvert) );
            Level = Aig_ObjLevel( pObjNew );
            Tim_ManSetCoArrival( (Tim_Man_t *)pMan->pManTime, pObj->PioId, (float)Level );
        }
        else if ( Nwk_ObjIsNode(pObj) )
        {
            pObjNew = Nwk_ManStrashNode( pMan, pObj );
        }
        else
            assert( 0 );
        pObj->pCopy = pObjNew;
    }
    Vec_PtrFree( vObjs );
    Aig_ManCleanup( pMan );
    Aig_ManSetRegNum( pMan, 0 );
    return pMan;
}

ABC_DLL Vec_Ptr_t* Nwk_ManSupportNodes	(	Nwk_Man_t *	pNtk,
		Nwk_Obj_t **	ppNodes,
		int	nNodes
	)

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

Synopsis [Returns the set of CI nodes in the support of the given nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 510 of file nwkDfs.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    // set the traversal ID
    Nwk_ManIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // go through the PO nodes and call for each of them
    for ( i = 0; i < nNodes; i++ )
        if ( Nwk_ObjIsCo(ppNodes[i]) )
            Nwk_ManSupportNodes_rec( Nwk_ObjFanin0(ppNodes[i]), vNodes );
        else
            Nwk_ManSupportNodes_rec( ppNodes[i], vNodes );
    return vNodes;
}

ABC_DLL void Nwk_ManSupportSum

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the sum total of supports of all outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 538 of file nwkDfs.c.

{
    Vec_Ptr_t * vSupp;
    Nwk_Obj_t * pObj;
    int i, nTotalSupps = 0;
    Nwk_ManForEachCo( pNtk, pObj, i )
    {
        vSupp = Nwk_ManSupportNodes( pNtk, &pObj, 1 );
        nTotalSupps += Vec_PtrSize( vSupp );
        Vec_PtrFree( vSupp );
    }
    printf( "Total supports = %d.\n", nTotalSupps );
}

static int Nwk_ManTimeEqual ( float  f1, float  f2, float  Eps  )

inlinestatic

Definition at line 171 of file nwk.h.

{ return (f1 < f2 + Eps) && (f2 < f1 + Eps);  }

static int Nwk_ManTimeLess ( float  f1, float  f2, float  Eps  )

inlinestatic

Definition at line 172 of file nwk.h.

{ return (f1 < f2 + Eps);                     }

static int Nwk_ManTimeMore ( float  f1, float  f2, float  Eps  )

inlinestatic

Definition at line 173 of file nwk.h.

{ return (f1 + Eps > f2);                     }

ABC_DLL void Nwk_ManUpdate	(	Nwk_Obj_t *	pObj,
		Nwk_Obj_t *	pObjNew,
		Vec_Vec_t *	vLevels
	)

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

Synopsis [Replaces the node and incrementally updates levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 860 of file nwkTiming.c.

{
    assert( pObj->pMan == pObjNew->pMan );
    assert( pObj != pObjNew );
    assert( Nwk_ObjFanoutNum(pObj) > 0 );
    assert( Nwk_ObjIsNode(pObj) && !Nwk_ObjIsCo(pObjNew) );
    // transfer fanouts to the old node
    Nwk_ObjTransferFanout( pObj, pObjNew );
    // transfer the timing information
    // (this is needed because updating level happens if the level has changed;
    // when we set the old level, it will be recomputed by the level updating
    // procedure, which will update level of other nodes if there is a difference)
    pObjNew->Level = pObj->Level;
    pObjNew->tArrival = pObj->tArrival;
    pObjNew->tRequired = pObj->tRequired;
    // update required times of the old fanins
    pObj->tRequired = TIM_ETERNITY;
    Nwk_NodeUpdateRequired( pObj );
    // remove the old node
    Nwk_ManDeleteNode_rec( pObj );
    // update the information of the new node
    Nwk_ManUpdateLevel( pObjNew );
    Nwk_NodeUpdateArrival( pObjNew );
    Nwk_NodeUpdateRequired( pObjNew );
//Nwk_ManVerifyTiming( pObjNew->pMan );
}

ABC_DLL int Nwk_ManVerifyLevel

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the level of the node using its fanin levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 832 of file nwkTiming.c.

{
    Nwk_Obj_t * pObj;
    int LevelNew, i;
    Nwk_ManForEachObj( pNtk, pObj, i )
    {
        assert( pObj->MarkA == 0 );
        LevelNew = Nwk_ObjLevelNew( pObj );
        if ( Nwk_ObjLevel(pObj) != LevelNew )
        {
            printf( "Object %6d: Mismatch betweeh levels: Actual = %d. Correct = %d.\n", 
                i, Nwk_ObjLevel(pObj), LevelNew );
        }
    }
    return 1;
}

ABC_DLL int Nwk_ManVerifyTiming

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Computes the arrival times for the given node.]

Description []

SideEffects []

SeeAlso []

Definition at line 427 of file nwkTiming.c.

{
    Nwk_Obj_t * pObj;
    float tArrival, tRequired;
    int i;
    Nwk_ManForEachObj( pNtk, pObj, i )
    {
        if ( Nwk_ObjIsCi(pObj) && Nwk_ObjFanoutNum(pObj) == 0 )
            continue;
        tArrival = Nwk_NodeComputeArrival( pObj, 1 );
        tRequired = Nwk_NodeComputeRequired( pObj, 1 );
        if ( !Nwk_ManTimeEqual( tArrival, Nwk_ObjArrival(pObj), (float)0.01 ) )
            printf( "Nwk_ManVerifyTiming(): Object %d has different arrival time (%.2f) from computed (%.2f).\n", 
                pObj->Id, Nwk_ObjArrival(pObj), tArrival );
        if ( !Nwk_ManTimeEqual( tRequired, Nwk_ObjRequired(pObj), (float)0.01 ) )
            printf( "Nwk_ManVerifyTiming(): Object %d has different required time (%.2f) from computed (%.2f).\n", 
                pObj->Id, Nwk_ObjRequired(pObj), tRequired );
    }
    return 1;
}

ABC_DLL int Nwk_ManVerifyTopoOrder

(

Nwk_Man_t *

pNtk

)

DECLARATIONS ///.

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

FileName [nwkDfs.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [DFS traversals.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

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

Synopsis [Verifies that the objects are in a topo order.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file nwkDfs.c.

{
    Nwk_Obj_t * pObj, * pNext;
    int i, k, iBox, iTerm1, nTerms;
    Nwk_ManIncrementTravId( pNtk );
    Nwk_ManForEachObj( pNtk, pObj, i )
    {
        if ( Nwk_ObjIsNode(pObj) || Nwk_ObjIsCo(pObj) )
        {
            Nwk_ObjForEachFanin( pObj, pNext, k )
            {
                if ( !Nwk_ObjIsTravIdCurrent(pNext) )
                {
                    printf( "Node %d has fanin %d that is not in a topological order.\n", pObj->Id, pNext->Id );
                    return 0;
                }
            }
        }
        else if ( Nwk_ObjIsCi(pObj) )
        {
            if ( pNtk->pManTime )
            {
                iBox = Tim_ManBoxForCi( pNtk->pManTime, pObj->PioId );
                if ( iBox >= 0 ) // this is not a true PI
                {
                    iTerm1 = Tim_ManBoxInputFirst( pNtk->pManTime, iBox );
                    nTerms = Tim_ManBoxInputNum( pNtk->pManTime, iBox );
                    for ( k = 0; k < nTerms; k++ )
                    {
                        pNext = Nwk_ManCo( pNtk, iTerm1 + k );
                        if ( !Nwk_ObjIsTravIdCurrent(pNext) )
                        {
                            printf( "Box %d has input %d that is not in a topological order.\n", iBox, pNext->Id );
                            return 0;
                        }
                    }
                }
            }
        }
        else
            assert( 0 );
        Nwk_ObjSetTravIdCurrent( pObj );
    }
    return 1;
}

ABC_DLL Nwk_Man_t* Nwk_MappingIf	(	Aig_Man_t *	p,
		Tim_Man_t *	pManTime,
		If_Par_t *	pPars
	)

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

Synopsis [Interface with the FPGA mapping package.]

Description []

SideEffects []

SeeAlso []

Definition at line 360 of file nwkMap.c.

{
    Nwk_Man_t * pNtk;
    If_Man_t * pIfMan;
    Vec_Ptr_t * vAigToIf;
    // set the arrival times
    pPars->pTimesArr = ABC_ALLOC( float, Aig_ManCiNum(p) );
    memset( pPars->pTimesArr, 0, sizeof(float) * Aig_ManCiNum(p) );
    // translate into the mapper
    vAigToIf = Vec_PtrStart( Aig_ManObjNumMax(p) );
    pIfMan = Nwk_ManToIf( p, pPars, vAigToIf );    
    if ( pIfMan == NULL )
        return NULL;
    pIfMan->pManTim = Tim_ManDup( pManTime, 0 );
    pIfMan->pPars->fCutMin = 0; // is not compatible with deriving result
    if ( !If_ManPerformMapping( pIfMan ) )
    {
        If_ManStop( pIfMan );
        return NULL;
    }
    // transform the result of mapping into the new network
    pNtk = Nwk_ManFromIf( pIfMan, p, vAigToIf );
    if ( pPars->fBidec && pPars->nLutSize <= 8 )
        Nwk_ManBidecResyn( pNtk, 0 );
    If_ManStop( pIfMan );
    Vec_PtrFree( vAigToIf );
    return pNtk;
}

ABC_DLL int Nwk_NodeCompareLevelsDecrease	(	Nwk_Obj_t **	pp1,
		Nwk_Obj_t **	pp2
	)

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

Synopsis [Procedure used for sorting the nodes in decreasing order of levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 205 of file nwkUtil.c.

{
    int Diff = (*pp1)->Level - (*pp2)->Level;
    if ( Diff > 0 )
        return -1;
    if ( Diff < 0 ) 
        return 1;
    return 0; 
}

ABC_DLL int Nwk_NodeCompareLevelsIncrease	(	Nwk_Obj_t **	pp1,
		Nwk_Obj_t **	pp2
	)

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

Synopsis [Procedure used for sorting the nodes in increasing order of levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 184 of file nwkUtil.c.

{
    int Diff = (*pp1)->Level - (*pp2)->Level;
    if ( Diff < 0 )
        return -1;
    if ( Diff > 0 ) 
        return 1;
    return 0; 
}

ABC_DLL Hop_Obj_t* Nwk_NodeIfNodeResyn	(	Bdc_Man_t *	p,
		Hop_Man_t *	pHop,
		Hop_Obj_t *	pRoot,
		int	nVars,
		Vec_Int_t *	vTruth,
		unsigned *	puCare,
		float	dProb
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Resynthesizes nodes using bi-decomposition.]

Description []

SideEffects []

SeeAlso []

Definition at line 67 of file nwkBidec.c.

{
    unsigned * pTruth;
    Bdc_Fun_t * pFunc;
    int nNodes, i;
    assert( nVars <= 16 );
    // derive truth table
    pTruth = Hop_ManConvertAigToTruth( pHop, Hop_Regular(pRoot), nVars, vTruth, 0 );
    if ( Hop_IsComplement(pRoot) )
        for ( i = Abc_TruthWordNum(nVars)-1; i >= 0; i-- )
            pTruth[i] = ~pTruth[i];
    // perform power-aware decomposition
    if ( dProb >= 0.0 )
    {
        float Prob = (float)2.0 * dProb * (1.0 - dProb);
        assert( Prob >= 0.0 && Prob <= 0.5 );
        if ( Prob >= 0.4 )
        {
            Extra_TruthNot( puCare, puCare, nVars );
            if ( dProb > 0.5 ) // more 1s than 0s
                Extra_TruthOr( pTruth, pTruth, puCare, nVars );
            else
                Extra_TruthSharp( pTruth, pTruth, puCare, nVars );
            Extra_TruthNot( puCare, puCare, nVars );
            // decompose truth table
            Bdc_ManDecompose( p, pTruth, NULL, nVars, NULL, 1000 );
        }
        else
        {
            // decompose truth table
            Bdc_ManDecompose( p, pTruth, puCare, nVars, NULL, 1000 );
        }
    }
    else
    {
        // decompose truth table
        Bdc_ManDecompose( p, pTruth, puCare, nVars, NULL, 1000 );
    }
    // convert back into HOP
    Bdc_FuncSetCopy( Bdc_ManFunc( p, 0 ), Hop_ManConst1( pHop ) );
    for ( i = 0; i < nVars; i++ )
        Bdc_FuncSetCopy( Bdc_ManFunc( p, i+1 ), Hop_ManPi( pHop, i ) );
    nNodes = Bdc_ManNodeNum(p);
    for ( i = nVars + 1; i < nNodes; i++ )
    {
        pFunc = Bdc_ManFunc( p, i );
        Bdc_FuncSetCopy( pFunc, Hop_And( pHop, Bdc_FunCopyHop(Bdc_FuncFanin0(pFunc)), Bdc_FunCopyHop(Bdc_FuncFanin1(pFunc)) ) );
    }
    return Bdc_FunCopyHop( Bdc_ManRoot(p) );
}

ABC_DLL void Nwk_ObjAddFanin	(	Nwk_Obj_t *	pObj,
		Nwk_Obj_t *	pFanin
	)

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

Synopsis [Creates fanout/fanin relationship between the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 165 of file nwkFanio.c.

{
    int i;
    assert( pObj->pMan == pFanin->pMan );
    assert( pObj->Id >= 0 && pFanin->Id >= 0 );
    if ( Nwk_ObjReallocIsNeeded(pObj) )
        Nwk_ManReallocNode( pObj );
    if ( Nwk_ObjReallocIsNeeded(pFanin) )
        Nwk_ManReallocNode( pFanin );
    for ( i = pObj->nFanins + pObj->nFanouts; i > pObj->nFanins; i-- )
        pObj->pFanio[i] = pObj->pFanio[i-1];
    pObj->pFanio[pObj->nFanins++] = pFanin;
    pFanin->pFanio[pFanin->nFanins + pFanin->nFanouts++] = pObj;
    pObj->Level = Abc_MaxInt( pObj->Level, pFanin->Level + Nwk_ObjIsNode(pObj) );
}

static float Nwk_ObjArrival ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 155 of file nwk.h.

{ return pObj->tArrival;           }

ABC_DLL void Nwk_ObjCollectFanins	(	Nwk_Obj_t *	pNode,
		Vec_Ptr_t *	vNodes
	)

DECLARATIONS ///.

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

FileName [nwkFanio.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [Manipulation of fanins/fanouts.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

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

Synopsis [Collects fanins of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file nwkFanio.c.

{
    Nwk_Obj_t * pFanin;
    int i;
    Vec_PtrClear(vNodes);
    Nwk_ObjForEachFanin( pNode, pFanin, i )
        Vec_PtrPush( vNodes, pFanin );
}

ABC_DLL void Nwk_ObjCollectFanouts	(	Nwk_Obj_t *	pNode,
		Vec_Ptr_t *	vNodes
	)

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

Synopsis [Collects fanouts of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 65 of file nwkFanio.c.

{
    Nwk_Obj_t * pFanout;
    int i;
    Vec_PtrClear(vNodes);
    Nwk_ObjForEachFanout( pNode, pFanout, i )
        Vec_PtrPush( vNodes, pFanout );
}

ABC_DLL void Nwk_ObjDeleteFanin	(	Nwk_Obj_t *	pObj,
		Nwk_Obj_t *	pFanin
	)

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

Synopsis [Removes fanout/fanin relationship between the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file nwkFanio.c.

{
    int i, k, Limit, fFound;
    // remove pFanin from the fanin list of pObj
    Limit = pObj->nFanins + pObj->nFanouts;
    fFound = 0;
    for ( k = i = 0; i < Limit; i++ )
        if ( fFound || pObj->pFanio[i] != pFanin )
            pObj->pFanio[k++] = pObj->pFanio[i];
        else
            fFound = 1;
    assert( i == k + 1 ); // if it fails, likely because of duplicated fanin
    pObj->nFanins--;
    // remove pObj from the fanout list of pFanin
    Limit = pFanin->nFanins + pFanin->nFanouts;
    fFound = 0;
    for ( k = i = pFanin->nFanins; i < Limit; i++ )
        if ( fFound || pFanin->pFanio[i] != pObj )
            pFanin->pFanio[k++] = pFanin->pFanio[i];
        else
            fFound = 1;
    assert( i == k + 1 ); // if it fails, likely because of duplicated fanout
    pFanin->nFanouts--; 
}

static Nwk_Obj_t* Nwk_ObjFanin ( Nwk_Obj_t *  p, int  i  )

inlinestatic

Definition at line 142 of file nwk.h.

{ return p->pFanio[i];                        } 

static Nwk_Obj_t* Nwk_ObjFanin0 ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 140 of file nwk.h.

{ return p->pFanio[0];                        } 

static int Nwk_ObjFaninNum ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 137 of file nwk.h.

{ return p->nFanins;                          } 

static Nwk_Obj_t* Nwk_ObjFanout ( Nwk_Obj_t *  p, int  i  )

inlinestatic

Definition at line 143 of file nwk.h.

{ return p->pFanio[p->nFanins+1];             } 

static Nwk_Obj_t* Nwk_ObjFanout0 ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 141 of file nwk.h.

{ return p->pFanio[p->nFanins];               } 

static int Nwk_ObjFanoutNum ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 138 of file nwk.h.

{ return p->nFanouts;                         } 

ABC_DLL int Nwk_ObjFindFanin	(	Nwk_Obj_t *	pObj,
		Nwk_Obj_t *	pFanin
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 85 of file nwkFanio.c.

{  
    Nwk_Obj_t * pTemp;
    int i;
    Nwk_ObjForEachFanin( pObj, pTemp, i )
        if ( pTemp == pFanin )
            return i;
    return -1;
}

ABC_DLL int Nwk_ObjFindFanout	(	Nwk_Obj_t *	pObj,
		Nwk_Obj_t *	pFanout
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 106 of file nwkFanio.c.

{  
    Nwk_Obj_t * pTemp;
    int i;
    Nwk_ObjForEachFanout( pObj, pTemp, i )
        if ( pTemp == pFanout )
            return i;
    return -1;
}

static int Nwk_ObjId ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 135 of file nwk.h.

{ return p->Id;                               } 

static int Nwk_ObjIsCi ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 146 of file nwk.h.

{ return p->Type == NWK_OBJ_CI;               } 

static int Nwk_ObjIsCo ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 147 of file nwk.h.

{ return p->Type == NWK_OBJ_CO;               } 

static int Nwk_ObjIsLatch ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 149 of file nwk.h.

{ return p->Type == NWK_OBJ_LATCH;            } 

static int Nwk_ObjIsLi ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 152 of file nwk.h.

{ return p->pMan->nTruePos && Nwk_ObjIsCo(p) && (int)p->PioId >= p->pMan->nTruePos;       } 

static int Nwk_ObjIsLo ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 153 of file nwk.h.

{ return p->pMan->nTruePis && Nwk_ObjIsCi(p) && (int)p->PioId >= p->pMan->nTruePis;       } 

static int Nwk_ObjIsNode ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 148 of file nwk.h.

{ return p->Type == NWK_OBJ_NODE;             } 

static int Nwk_ObjIsNone ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 145 of file nwk.h.

{ return p->Type == NWK_OBJ_NONE;             } 

static int Nwk_ObjIsPi ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 150 of file nwk.h.

{ return Nwk_ObjIsCi(p) && (p->pMan->pManTime == NULL || Tim_ManBoxForCi(p->pMan->pManTime, p->PioId) == -1); } 

static int Nwk_ObjIsPo ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 151 of file nwk.h.

{ return Nwk_ObjIsCo(p) && (p->pMan->pManTime == NULL || Tim_ManBoxForCo(p->pMan->pManTime, p->PioId) == -1);  }

static int Nwk_ObjIsTravIdCurrent ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 168 of file nwk.h.

{ return pObj->TravId == pObj->pMan->nTravIds;     }

static int Nwk_ObjIsTravIdPrevious ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 169 of file nwk.h.

{ return pObj->TravId == pObj->pMan->nTravIds - 1; }

static int Nwk_ObjLevel ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 162 of file nwk.h.

{ return pObj->Level;              }

ABC_DLL int Nwk_ObjMffcLabel

(

Nwk_Obj_t *

pNode

)

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

Synopsis [Collects the internal nodes of the MFFC limited by cut.]

Description []

SideEffects [Increments the trav ID and marks visited nodes.]

SeeAlso []

Definition at line 644 of file nwkDfs.c.

{
    int Count1, Count2;
    // dereference the node
    Count1 = Nwk_ObjDeref_rec( pNode );
    // collect the nodes inside the MFFC
    Nwk_ManIncrementTravId( pNode->pMan );
    Nwk_ObjMffcLabel_rec( pNode, 1 );
    // reference it back
    Count2 = Nwk_ObjRef_rec( pNode );
    assert( Count1 == Count2 );
    return Count1;
}

ABC_DLL void Nwk_ObjPatchFanin	(	Nwk_Obj_t *	pObj,
		Nwk_Obj_t *	pFaninOld,
		Nwk_Obj_t *	pFaninNew
	)

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

Synopsis [Replaces a fanin of the node.]

Description [The node is pObj. An old fanin of this node (pFaninOld) has to be replaced by a new fanin (pFaninNew). Assumes that the node and the old fanin are not complemented. The new fanin can be complemented. In this case, the polarity of the new fanin will change, compared to the polarity of the old fanin.]

SideEffects []

SeeAlso []

Definition at line 231 of file nwkFanio.c.

{
    int i, k, iFanin, Limit;
    assert( pFaninOld != pFaninNew );
    assert( pObj != pFaninOld );
    assert( pObj != pFaninNew );
    assert( pObj->pMan == pFaninOld->pMan );
    assert( pObj->pMan == pFaninNew->pMan );
    // update the fanin
    iFanin = Nwk_ObjFindFanin( pObj, pFaninOld );
    if ( iFanin == -1 )
    {
        printf( "Nwk_ObjPatchFanin(); Error! Node %d is not among", pFaninOld->Id );
        printf( " the fanins of node %d...\n", pObj->Id );
        return;
    }
    pObj->pFanio[iFanin] = pFaninNew;
    // remove pObj from the fanout list of pFaninOld
    Limit = pFaninOld->nFanins + pFaninOld->nFanouts;
    for ( k = i = pFaninOld->nFanins; i < Limit; i++ )
        if ( pFaninOld->pFanio[i] != pObj )
            pFaninOld->pFanio[k++] = pFaninOld->pFanio[i];
    pFaninOld->nFanouts--;
    // add pObj to the fanout list of pFaninNew
    if ( Nwk_ObjReallocIsNeeded(pFaninNew) )
        Nwk_ManReallocNode( pFaninNew );
    pFaninNew->pFanio[pFaninNew->nFanins + pFaninNew->nFanouts++] = pObj;
}

static int Nwk_ObjPioNum ( Nwk_Obj_t *  p )

inlinestatic

Definition at line 136 of file nwk.h.

{ return p->PioId;                            } 

ABC_DLL void Nwk_ObjPrint

(

Nwk_Obj_t *

pObj

)

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

Synopsis [Prints the objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 226 of file nwkUtil.c.

{
    Nwk_Obj_t * pNext;
    int i;
    printf( "ObjId = %5d.  ", pObj->Id );
    if ( Nwk_ObjIsPi(pObj) )
        printf( "PI" );
    if ( Nwk_ObjIsPo(pObj) )
        printf( "PO" );
    if ( Nwk_ObjIsNode(pObj) )
        printf( "Node" );
    printf( "   Fanins = " );
    Nwk_ObjForEachFanin( pObj, pNext, i )
        printf( "%d ", pNext->Id );
    printf( "   Fanouts = " );
    Nwk_ObjForEachFanout( pObj, pNext, i )
        printf( "%d ", pNext->Id );
    printf( "\n" );
}

ABC_DLL void Nwk_ObjReplace	(	Nwk_Obj_t *	pNodeOld,
		Nwk_Obj_t *	pNodeNew
	)

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

Synopsis [Replaces the node by a new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 302 of file nwkFanio.c.

{
    assert( pNodeOld->pMan == pNodeNew->pMan );
    assert( pNodeOld != pNodeNew );
    assert( Nwk_ObjFanoutNum(pNodeOld) > 0 );
    // transfer the fanouts to the old node
    Nwk_ObjTransferFanout( pNodeOld, pNodeNew );
    // remove the old node
    Nwk_ManDeleteNode_rec( pNodeOld );
}

static float Nwk_ObjRequired ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 156 of file nwk.h.

{ return pObj->tRequired;          }

static void Nwk_ObjSetArrival ( Nwk_Obj_t *  pObj, float  Time  )

inlinestatic

Definition at line 158 of file nwk.h.

{ pObj->tArrival   = Time;         }

static void Nwk_ObjSetLevel ( Nwk_Obj_t *  pObj, int  Level  )

inlinestatic

Definition at line 163 of file nwk.h.

{ pObj->Level = Level;             }

static void Nwk_ObjSetRequired ( Nwk_Obj_t *  pObj, float  Time  )

inlinestatic

Definition at line 159 of file nwk.h.

{ pObj->tRequired  = Time;         }

static void Nwk_ObjSetSlack ( Nwk_Obj_t *  pObj, float  Time  )

inlinestatic

Definition at line 160 of file nwk.h.

{ pObj->tSlack     = Time;         }

static void Nwk_ObjSetTravId ( Nwk_Obj_t *  pObj, int  TravId  )

inlinestatic

Definition at line 165 of file nwk.h.

{ pObj->TravId = TravId;                           }

static void Nwk_ObjSetTravIdCurrent ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 166 of file nwk.h.

{ pObj->TravId = pObj->pMan->nTravIds;             }

static void Nwk_ObjSetTravIdPrevious ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 167 of file nwk.h.

{ pObj->TravId = pObj->pMan->nTravIds - 1;         }

static float Nwk_ObjSlack ( Nwk_Obj_t *  pObj )

inlinestatic

Definition at line 157 of file nwk.h.

{ return pObj->tSlack;             }

ABC_DLL void Nwk_ObjTransferFanout	(	Nwk_Obj_t *	pNodeFrom,
		Nwk_Obj_t *	pNodeTo
	)

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

Synopsis [Transfers fanout from the old node to the new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 272 of file nwkFanio.c.

{
    Vec_Ptr_t * vFanouts = pNodeFrom->pMan->vTemp;
    Nwk_Obj_t * pTemp;
    int nFanoutsOld, i;
    assert( !Nwk_ObjIsCo(pNodeFrom) && !Nwk_ObjIsCo(pNodeTo) );
    assert( pNodeFrom->pMan == pNodeTo->pMan );
    assert( pNodeFrom != pNodeTo );
    assert( Nwk_ObjFanoutNum(pNodeFrom) > 0 );
    // get the fanouts of the old node
    nFanoutsOld = Nwk_ObjFanoutNum(pNodeTo);
    Nwk_ObjCollectFanouts( pNodeFrom, vFanouts );
    // patch the fanin of each of them
    Vec_PtrForEachEntry( Nwk_Obj_t *, vFanouts, pTemp, i )
        Nwk_ObjPatchFanin( pTemp, pNodeFrom, pNodeTo );
    assert( Nwk_ObjFanoutNum(pNodeFrom) == 0 );
    assert( Nwk_ObjFanoutNum(pNodeTo) == nFanoutsOld + Vec_PtrSize(vFanouts) );
}

ABC_DLL float Nwl_ManComputeTotalSwitching

(

Nwk_Man_t *

pNtk

)

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

Synopsis [Marks nodes for power-optimization.]

Description []

SideEffects []

SeeAlso []

Definition at line 198 of file nwkMan.c.

{
    extern Vec_Int_t * Saig_ManComputeSwitchProbs( Aig_Man_t * p, int nFrames, int nPref, int fProbOne );
    Vec_Int_t * vSwitching;
    float * pSwitching;
    Aig_Man_t * pAig;
    Aig_Obj_t * pObjAig;
    Nwk_Obj_t * pObjAbc;
    float Result = (float)0;
    int i;
    // strash the network
    // map network into an AIG
    pAig = Nwk_ManStrash( pNtk );
    vSwitching = Saig_ManComputeSwitchProbs( pAig, 48, 16, 0 );
    pSwitching = (float *)vSwitching->pArray;
    Nwk_ManForEachObj( pNtk, pObjAbc, i )
    {
        if ( (pObjAig = Aig_Regular((Aig_Obj_t *)pObjAbc->pCopy)) )
            Result += Nwk_ObjFanoutNum(pObjAbc) * pSwitching[pObjAig->Id];
    }
    Vec_IntFree( vSwitching );
    Aig_ManStop( pAig );
    return Result;
}