sclSize.h File Reference

#include "base/abc/abc.h"
#include "misc/vec/vecQue.h"
#include "misc/vec/vecWec.h"
#include "sclLib.h"

Go to the source code of this file.

Data Structures
struct	SC_Man_

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct SC_Man_	SC_Man
	INCLUDES ///. More...

Functions
static SC_Lib *	Abc_SclObjLib (Abc_Obj_t *p)
	GLOBAL VARIABLES ///. More...
static int	Abc_SclObjCellId (Abc_Obj_t *p)
static SC_Cell *	Abc_SclObjCell (Abc_Obj_t *p)
static void	Abc_SclObjSetCell (Abc_Obj_t *p, SC_Cell *pCell)
static SC_Pair *	Abc_SclObjLoad (SC_Man *p, Abc_Obj_t *pObj)
static SC_Pair *	Abc_SclObjDept (SC_Man *p, Abc_Obj_t *pObj)
static SC_Pair *	Abc_SclObjTime (SC_Man *p, Abc_Obj_t *pObj)
static SC_Pair *	Abc_SclObjSlew (SC_Man *p, Abc_Obj_t *pObj)
static double	Abc_SclObjLoadMax (SC_Man *p, Abc_Obj_t *pObj)
static float	Abc_SclObjLoadAve (SC_Man *p, Abc_Obj_t *pObj)
static double	Abc_SclObjTimeOne (SC_Man *p, Abc_Obj_t *pObj, int fRise)
static float	Abc_SclObjTimeMax (SC_Man *p, Abc_Obj_t *pObj)
static double	Abc_SclObjSlewMax (SC_Man *p, Abc_Obj_t *pObj)
static float	Abc_SclObjGetSlackR (SC_Man *p, Abc_Obj_t *pObj, float D)
static float	Abc_SclObjGetSlackF (SC_Man *p, Abc_Obj_t *pObj, float D)
static float	Abc_SclObjGetSlack (SC_Man *p, Abc_Obj_t *pObj, float D)
static double	Abc_SclObjSlackMax (SC_Man *p, Abc_Obj_t *pObj, float D)
static void	Abc_SclObjDupFanin (SC_Man *p, Abc_Obj_t *pObj)
static float	Abc_SclObjInDrive (SC_Man *p, Abc_Obj_t *pObj)
static void	Abc_SclObjSetInDrive (SC_Man *p, Abc_Obj_t *pObj, float c)
static SC_Man *	Abc_SclManAlloc (SC_Lib *pLib, Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///. More...
static void	Abc_SclManFree (SC_Man *p)
static void	Abc_SclManCleanTime (SC_Man *p)
static void	Abc_SclLoadStore (SC_Man *p, Abc_Obj_t *pObj)
static void	Abc_SclLoadRestore (SC_Man *p, Abc_Obj_t *pObj)
static void	Abc_SclLoadStore3 (SC_Man *p, Abc_Obj_t *pObj)
static void	Abc_SclLoadRestore3 (SC_Man *p, Abc_Obj_t *pObj)
static void	Abc_SclConeStore (SC_Man *p, Vec_Int_t *vCone)
static void	Abc_SclConeRestore (SC_Man *p, Vec_Int_t *vCone)
static void	Abc_SclEvalStore (SC_Man *p, Vec_Int_t *vCone)
static float	Abc_SclEvalPerform (SC_Man *p, Vec_Int_t *vCone)
static float	Abc_SclEvalPerformLegal (SC_Man *p, Vec_Int_t *vCone, float D)
static void	Abc_SclConeClean (SC_Man *p, Vec_Int_t *vCone)
static int	Abc_SclGetBufInvCount (Abc_Ntk_t *pNtk)
static float	Abc_SclGetAverageSize (Abc_Ntk_t *pNtk)
static float	Abc_SclGetTotalArea (Abc_Ntk_t *pNtk)
static float	Abc_SclGetMaxDelay (SC_Man *p)
static float	Abc_SclGetMaxDelayNodeFanins (SC_Man *p, Abc_Obj_t *pNode)
static float	Abc_SclReadMaxDelay (SC_Man *p)
static SC_Cell *	Abc_SclObjResiable (SC_Man *p, Abc_Obj_t *pObj, int fUpsize)
static void	Abc_SclDumpStats (SC_Man *p, char *pFileName, abctime Time)
Abc_Ntk_t *	Abc_SclBufferingPerform (Abc_Ntk_t *pNtk, SC_Lib *pLib, SC_BusPars *pPars)
int	Abc_SclIsInv (Abc_Obj_t *pObj)
void	Abc_NodeInvUpdateFanPolarity (Abc_Obj_t *pObj)
void	Abc_NodeInvUpdateObjFanoutPolarity (Abc_Obj_t *pObj, Abc_Obj_t *pFanout)
void	Abc_SclReportDupFanins (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///. More...
Abc_Ntk_t *	Abc_SclUnBufferPerform (Abc_Ntk_t *pNtk, int fVerbose)
Abc_Ntk_t *	Abc_SclUnBufferPhase (Abc_Ntk_t *pNtk, int fVerbose)
Abc_Ntk_t *	Abc_SclBufferPhase (Abc_Ntk_t *pNtk, int fVerbose)
int	Abc_SclCheckNtk (Abc_Ntk_t *p, int fVerbose)
Abc_Ntk_t *	Abc_SclPerformBuffering (Abc_Ntk_t *p, int DegreeR, int Degree, int fUseInvs, int fVerbose)
Abc_Ntk_t *	Abc_SclBufPerform (Abc_Ntk_t *pNtk, int FanMin, int FanMax, int fBufPis, int fSkipDup, int fVerbose)
void	Abc_SclDnsizePerform (SC_Lib *pLib, Abc_Ntk_t *pNtk, SC_SizePars *pPars)
Vec_Flt_t *	Abc_SclFindWireCaps (SC_WireLoad *pWL, int nFanoutMax)
	DECLARATIONS ///. More...
float	Abc_SclFindWireLoad (Vec_Flt_t *vWireCaps, int nFans)
void	Abc_SclAddWireLoad (SC_Man *p, Abc_Obj_t *pObj, int fSubtr)
void	Abc_SclComputeLoad (SC_Man *p)
void	Abc_SclUpdateLoad (SC_Man *p, Abc_Obj_t *pObj, SC_Cell *pOld, SC_Cell *pNew)
void	Abc_SclUpdateLoadSplit (SC_Man *p, Abc_Obj_t *pBuffer, Abc_Obj_t *pFanout)
Abc_Obj_t *	Abc_SclFindCriticalCo (SC_Man *p, int *pfRise)
	DECLARATIONS ///. More...
Abc_Obj_t *	Abc_SclFindMostCriticalFanin (SC_Man *p, int *pfRise, Abc_Obj_t *pNode)
void	Abc_SclTimeNtkPrint (SC_Man *p, int fShowAll, int fPrintPath)
SC_Man *	Abc_SclManStart (SC_Lib *pLib, Abc_Ntk_t *pNtk, int fUseWireLoads, int fDept, float DUser, int nTreeCRatio)
void	Abc_SclTimeCone (SC_Man *p, Vec_Int_t *vCone)
void	Abc_SclTimeNtkRecompute (SC_Man *p, float *pArea, float *pDelay, int fReverse, float DUser)
int	Abc_SclTimeIncUpdate (SC_Man *p)
void	Abc_SclTimeIncInsert (SC_Man *p, Abc_Obj_t *pObj)
void	Abc_SclTimeIncUpdateLevel (Abc_Obj_t *pObj)
void	Abc_SclTimePerform (SC_Lib *pLib, Abc_Ntk_t *pNtk, int nTreeCRatio, int fUseWireLoads, int fShowAll, int fPrintPath, int fDumpStats)
void	Abc_SclPrintBuffers (SC_Lib *pLib, Abc_Ntk_t *pNtk, int fVerbose)
int	Abc_SclCountNearCriticalNodes (SC_Man *p)
void	Abc_SclUpsizePerform (SC_Lib *pLib, Abc_Ntk_t *pNtk, SC_SizePars *pPars)
void	Abc_SclMioGates2SclGates (SC_Lib *pLib, Abc_Ntk_t *p)
	DECLARATIONS ///. More...
void	Abc_SclSclGates2MioGates (SC_Lib *pLib, Abc_Ntk_t *p)
void	Abc_SclPrintGateSizes (SC_Lib *pLib, Abc_Ntk_t *p)
void	Abc_SclMinsizePerform (SC_Lib *pLib, Abc_Ntk_t *p, int fUseMax, int fVerbose)
int	Abc_SclCountMinSize (SC_Lib *pLib, Abc_Ntk_t *p, int fUseMax)
Vec_Int_t *	Abc_SclExtractBarBufs (Abc_Ntk_t *pNtk)
void	Abc_SclInsertBarBufs (Abc_Ntk_t *pNtk, Vec_Int_t *vBufs)

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct SC_Man_ SC_Man

INCLUDES ///.

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

FileName [sclSize.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Standard-cell library representation.]

Synopsis [Timing/gate-sizing manager.]

Author [Alan Mishchenko, Niklas Een]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 24, 2012.]

Revision [

Id:

sclSize.h,v 1.0 2012/08/24 00:00:00 alanmi Exp

]PARAMETERS ///STRUCTURE DEFINITIONS ///

Definition at line 44 of file sclSize.h.

Function Documentation

void Abc_NodeInvUpdateFanPolarity

(

Abc_Obj_t *

pObj

)

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

Synopsis [Performs buffering of the mapped network (old code).]

Description []

SideEffects []

SeeAlso []

Definition at line 320 of file sclBuffer.c.

{
    Abc_Obj_t * pFanout;
    int i;
    assert( Abc_ObjFaninNum(pObj) == 0 || Abc_SclObjIsBufInv(pObj) );
    Abc_ObjForEachFanout( pObj, pFanout, i )
    {
        assert( Abc_ObjFaninNum(pFanout) > 0 );
        if ( Abc_SclObjIsBufInv(pFanout) )
            Abc_NodeInvUpdateFanPolarity( pFanout );
        else
            Abc_ObjFaninFlipPhase( pFanout, Abc_NodeFindFanin(pFanout, pObj) );
    }
}

void Abc_NodeInvUpdateObjFanoutPolarity	(	Abc_Obj_t *	pObj,
		Abc_Obj_t *	pFanout
	)

Definition at line 334 of file sclBuffer.c.

{
    if ( Abc_SclObjIsBufInv(pFanout) )
        Abc_NodeInvUpdateFanPolarity( pFanout );
    else
        Abc_ObjFaninFlipPhase( pFanout, Abc_NodeFindFanin(pFanout, pObj) );
}

void Abc_SclAddWireLoad	(	SC_Man *	p,
		Abc_Obj_t *	pObj,
		int	fSubtr
	)

Definition at line 100 of file sclLoad.c.

{
    float Load = Abc_SclFindWireLoad( p->vWireCaps, Abc_ObjFanoutNum(pObj) );
    Abc_SclObjLoad(p, pObj)->rise += fSubtr ? -Load : Load;
    Abc_SclObjLoad(p, pObj)->fall += fSubtr ? -Load : Load;
}

Abc_Ntk_t* Abc_SclBufferingPerform	(	Abc_Ntk_t *	pNtk,
		SC_Lib *	pLib,
		SC_BusPars *	pPars
	)

Definition at line 480 of file sclBufSize.c.

{
    Abc_Ntk_t * pNtkNew;
    Bus_Man_t * p;
    if ( !Abc_SclCheckNtk( pNtk, 0 ) )
        return NULL;
    Abc_SclReportDupFanins( pNtk );
    Abc_SclMioGates2SclGates( pLib, pNtk );
    p = Bus_ManStart( pNtk, pLib, pPars );
    Bus_ManReadInOutLoads( p );
    Abc_SclBufSize( p, 0.01 * pPars->GainRatio );
    Bus_ManStop( p );
    Abc_SclSclGates2MioGates( pLib, pNtk );
    if ( pNtk->vPhases )
        Vec_IntFillExtra( pNtk->vPhases, Abc_NtkObjNumMax(pNtk), 0 );
    pNtkNew = Abc_NtkDupDfs( pNtk );
    return pNtkNew;
}

Abc_Ntk_t* Abc_SclBufferPhase	(	Abc_Ntk_t *	pNtk,
		int	fVerbose
	)

Definition at line 198 of file sclBuffer.c.

{
    Abc_Ntk_t * pNtkNew;
    Vec_Int_t * vInvs;
    Abc_Obj_t * pObj, * pFanin, * pFaninNew;
    int nNodesOld = Abc_NtkObjNumMax(pNtk);
    int i, k, Counter = 0, Counter2 = 0, Total = 0;
    assert( pNtk->vPhases != NULL );
    vInvs = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachNodeCo( pNtk, pObj, i )
    {
        if ( i >= nNodesOld )
            break;
        Abc_ObjForEachFanin( pObj, pFanin, k )
        {
            Total++;
            if ( !Abc_ObjFaninPhase(pObj, k) )
                continue;
            if ( Vec_IntEntry(vInvs, Abc_ObjId(pFanin)) == 0 || Abc_ObjIsCi(pFanin) ) // allow PIs to have high fanout - to be fixed later
            {
                pFaninNew = Abc_NtkCreateNodeInv( pNtk, pFanin );
                Vec_IntWriteEntry( vInvs, Abc_ObjId(pFanin), Abc_ObjId(pFaninNew) );
                Counter++;
            }
            pFaninNew = Abc_NtkObj( pNtk, Vec_IntEntry(vInvs, Abc_ObjId(pFanin)) );
            Abc_ObjPatchFanin( pObj, pFanin, pFaninNew );
            Counter2++;
        }
    }
    if ( fVerbose )
        printf( "Added %d inverters (%.2f %% fanins) (%.2f %% compl fanins).\n", 
            Counter, 100.0 * Counter / Total, 100.0 * Counter2 / Total );
    Vec_IntFree( vInvs );
    Vec_IntFillExtra( pNtk->vPhases, Abc_NtkObjNumMax(pNtk), 0 );
    // duplicate network in topo order
    vInvs = pNtk->vPhases;
    pNtk->vPhases = NULL;
    pNtkNew = Abc_NtkDupDfs( pNtk );
    pNtk->vPhases = vInvs;
    return pNtkNew;
}

Abc_Ntk_t* Abc_SclBufPerform	(	Abc_Ntk_t *	pNtk,
		int	FanMin,
		int	FanMax,
		int	fBufPis,
		int	fSkipDup,
		int	fVerbose
	)

Definition at line 984 of file sclBuffer.c.

{
    Abc_Ntk_t * pNew;
    Buf_Man_t * p = Buf_ManStart( pNtk, FanMin, FanMax, fBufPis );
    int i, Limit = ABC_INFINITY;
    Abc_NtkLevel( pNtk );
//    if ( Abc_NtkNodeNum(pNtk) < 1000 )
//        fSkipDup = 1;
    for ( i = 0; i < Limit && Vec_QueSize(p->vQue); i++ )
        Abc_BufPerformOne( p, Vec_QuePop(p->vQue), fSkipDup, fVerbose );
    Buf_ManStop( p );
//    Abc_BufReplaceBufsByInvs( pNtk );
    // duplicate network in topo order
    pNew = Abc_NtkDupDfs( pNtk );
    Abc_SclCheckNtk( pNew, fVerbose );
    return pNew;
}

int Abc_SclCheckNtk	(	Abc_Ntk_t *	p,
		int	fVerbose
	)

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

Synopsis [Make sure the network is in topo order without dangling nodes.]

Description [Returns 1 iff the network is fine.]

SideEffects []

SeeAlso []

Definition at line 286 of file sclBuffer.c.

{
    Abc_Obj_t * pObj, * pFanin;
    int i, k, fFlag = 1;
    Abc_NtkIncrementTravId( p );        
    Abc_NtkForEachCi( p, pObj, i )
        Abc_NodeSetTravIdCurrent( pObj );
    Abc_NtkForEachNode( p, pObj, i )
    {
        Abc_ObjForEachFanin( pObj, pFanin, k )
            if ( !Abc_NodeIsTravIdCurrent( pFanin ) )
                printf( "obj %d and its fanin %d are not in the topo order\n", Abc_ObjId(pObj), Abc_ObjId(pFanin) ), fFlag = 0;
        Abc_NodeSetTravIdCurrent( pObj );
        if ( Abc_ObjFanoutNum(pObj) == 0 )
            printf( "node %d has no fanout\n", Abc_ObjId(pObj) ), fFlag = 0;
        if ( !fFlag )
            break;
    }
    if ( fFlag && fVerbose )
        printf( "The network is in topo order and no dangling nodes.\n" );
    return fFlag;
}

void Abc_SclComputeLoad

(

SC_Man *

p

)

Definition at line 106 of file sclLoad.c.

{
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    // clear load storage
    Abc_NtkForEachObj( p->pNtk, pObj, i )
    {
        SC_Pair * pLoad = Abc_SclObjLoad( p, pObj );
        if ( !Abc_ObjIsPo(pObj) )
            pLoad->rise = pLoad->fall = 0.0;
    }
    // add cell load
    Abc_NtkForEachNode1( p->pNtk, pObj, i )
    {
        SC_Cell * pCell = Abc_SclObjCell( pObj );
        Abc_ObjForEachFanin( pObj, pFanin, k )
        {
            SC_Pair * pLoad = Abc_SclObjLoad( p, pFanin );
            SC_Pin * pPin = SC_CellPin( pCell, k );
            pLoad->rise += pPin->rise_cap;
            pLoad->fall += pPin->fall_cap;
        }
    }
    // add PO load
    Abc_NtkForEachCo( p->pNtk, pObj, i )
    {
        SC_Pair * pLoadPo = Abc_SclObjLoad( p, pObj );
        SC_Pair * pLoad = Abc_SclObjLoad( p, Abc_ObjFanin0(pObj) );
        pLoad->rise += pLoadPo->rise;
        pLoad->fall += pLoadPo->fall;
    }
    // add wire load
    if ( p->pWLoadUsed != NULL )
    {
        if ( p->vWireCaps == NULL )
            p->vWireCaps = Abc_SclFindWireCaps( p->pWLoadUsed, Abc_NtkGetFanoutMax(p->pNtk) );
        Abc_NtkForEachNode1( p->pNtk, pObj, i )
            Abc_SclAddWireLoad( p, pObj, 0 );
        Abc_NtkForEachPi( p->pNtk, pObj, i )
            Abc_SclAddWireLoad( p, pObj, 0 );
    }
    // check input loads
    if ( p->vInDrive != NULL )
    {
        Abc_NtkForEachPi( p->pNtk, pObj, i )
        {
            SC_Pair * pLoad = Abc_SclObjLoad( p, pObj );
            if ( Abc_SclObjInDrive(p, pObj) != 0 && (pLoad->rise > Abc_SclObjInDrive(p, pObj) || pLoad->fall > Abc_SclObjInDrive(p, pObj)) )
                printf( "Maximum input drive strength is exceeded at primary input %d.\n", i );
        }
    }
/*
    // transfer load from barbufs
    Abc_NtkForEachBarBuf( p->pNtk, pObj, i )
    {
        SC_Pair * pLoad = Abc_SclObjLoad( p, pObj );
        SC_Pair * pLoadF = Abc_SclObjLoad( p, Abc_ObjFanin(pObj, 0) );
        SC_PairAdd( pLoadF, pLoad );
    }
*/
    // calculate average load
//    if ( p->EstLoadMax )
    {
        double TotalLoad = 0;
        int nObjs = 0;
        Abc_NtkForEachNode1( p->pNtk, pObj, i )
        {
            SC_Pair * pLoad = Abc_SclObjLoad( p, pObj );
            TotalLoad += 0.5 * pLoad->fall + 0.5 * pLoad->rise;
            nObjs++;
        }
        Abc_NtkForEachPi( p->pNtk, pObj, i )
        {
            SC_Pair * pLoad = Abc_SclObjLoad( p, pObj );
            TotalLoad += 0.5 * pLoad->fall + 0.5 * pLoad->rise;
            nObjs++;
        }
        p->EstLoadAve = (float)(TotalLoad / nObjs);
//        printf( "Average load = %.2f\n", p->EstLoadAve );
    }
}

static void Abc_SclConeClean ( SC_Man *  p, Vec_Int_t *  vCone  )

inlinestatic

Definition at line 406 of file sclSize.h.

{
    SC_Pair Zero = { 0.0, 0.0 };
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        *Abc_SclObjTime(p, pObj) = Zero;
        *Abc_SclObjSlew(p, pObj) = Zero;
    }
}

static void Abc_SclConeRestore ( SC_Man *  p, Vec_Int_t *  vCone  )

inlinestatic

Definition at line 352 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    int i, k = 0;
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        Abc_SclObjTime(p, pObj)->rise = Vec_FltEntry(p->vTimes2, k++);
        Abc_SclObjTime(p, pObj)->fall = Vec_FltEntry(p->vTimes2, k++);
        Abc_SclObjSlew(p, pObj)->rise = Vec_FltEntry(p->vTimes2, k++);
        Abc_SclObjSlew(p, pObj)->fall = Vec_FltEntry(p->vTimes2, k++);
    }
    assert( Vec_FltSize(p->vTimes2) == k );
}

static void Abc_SclConeStore ( SC_Man *  p, Vec_Int_t *  vCone  )

inlinestatic

Definition at line 339 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    int i;
    Vec_FltClear( p->vTimes2 );
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        Vec_FltPush( p->vTimes2, Abc_SclObjTime(p, pObj)->rise );
        Vec_FltPush( p->vTimes2, Abc_SclObjTime(p, pObj)->fall );
        Vec_FltPush( p->vTimes2, Abc_SclObjSlew(p, pObj)->rise );
        Vec_FltPush( p->vTimes2, Abc_SclObjSlew(p, pObj)->fall );
    }
}

int Abc_SclCountMinSize	(	SC_Lib *	pLib,
		Abc_Ntk_t *	p,
		int	fUseMax
	)

Definition at line 203 of file sclUtil.c.

{
    Vec_Int_t * vMinCells;
    Abc_Obj_t * pObj;
    int i, gateId, Counter = 0;
    vMinCells = Abc_SclFindMinAreas( pLib, fUseMax );
    Abc_NtkForEachNode1( p, pObj, i )
    {
        gateId = Vec_IntEntry( p->vGates, i );
        Counter += ( gateId == Vec_IntEntry(vMinCells, gateId) );
    }
    Vec_IntFree( vMinCells );
    return Counter;
}

int Abc_SclCountNearCriticalNodes

(

SC_Man *

p

)

Definition at line 187 of file sclUpsize.c.

{
    int RetValue;
    Vec_Int_t * vPathPos, * vPathNodes;
    vPathPos   = Abc_SclFindCriticalCoWindow( p, 5 );
    vPathNodes = Abc_SclFindCriticalNodeWindow( p, vPathPos, 5, 0 );
    RetValue   = Vec_IntSize(vPathNodes);
    Abc_SclUnmarkCriticalNodeWindow( p, vPathNodes );
    Abc_SclUnmarkCriticalNodeWindow( p, vPathPos );
    Vec_IntFree( vPathPos );
    Vec_IntFree( vPathNodes );
    return RetValue;
}

void Abc_SclDnsizePerform	(	SC_Lib *	pLib,
		Abc_Ntk_t *	pNtk,
		SC_SizePars *	pPars
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 242 of file sclDnsize.c.

{
    SC_Man * p;
    Abc_Obj_t * pObj;
    Vec_Int_t * vNodes, * vEvals, * vTryLater; 
    abctime clk, nRuntimeLimit = pPars->TimeOut ? pPars->TimeOut * CLOCKS_PER_SEC + Abc_Clock() : 0;
    int i, k;

    if ( pPars->fVerbose )
    {
        printf( "Parameters: " );
        printf( "Iters =%5d.  ",          pPars->nIters    );
        printf( "UseDept =%2d. ",         pPars->fUseDept  );
        printf( "UseWL =%2d. ",           pPars->fUseWireLoads );
        printf( "Target =%5d ps. ",       pPars->DelayUser );
        printf( "DelayGap =%3d ps. ",     pPars->DelayGap );
        printf( "Timeout =%4d sec",       pPars->TimeOut   );
        printf( "\n" );
    }

    // prepare the manager; collect init stats
    p = Abc_SclManStart( pLib, pNtk, pPars->fUseWireLoads, pPars->fUseDept, pPars->DelayUser, pPars->BuffTreeEst );
    p->timeTotal  = Abc_Clock();
    assert( p->vGatesBest == NULL );
    p->vGatesBest = Vec_IntDup( p->pNtk->vGates );

    // perform upsizing
    vNodes = Vec_IntAlloc( 1000 );
    vEvals = Vec_IntAlloc( 1000 );
    vTryLater = Vec_IntAlloc( 1000 );
    for ( i = 0; i < pPars->nIters; i++ )
    {
        int nRounds = 0;
        int nAttemptAll = 0, nOverlapAll = 0, nChangesAll = 0;
        Abc_NtkCollectNodesByArea( p, pNtk );
        while ( Vec_QueSize(p->vNodeByGain) > 0 )
        {
            int nAttempt = 0, nOverlap = 0, nChanges = 0;
            Vec_IntClear( vTryLater );
            Abc_NtkIncrementTravId( pNtk );
            while ( Vec_QueSize(p->vNodeByGain) > 0 )
            {
                clk = Abc_Clock();
                pObj = Abc_NtkObj( p->pNtk, Vec_QuePop(p->vNodeByGain) );
                Abc_SclFindWindow( pObj, &vNodes, &vEvals );
                p->timeCone += Abc_Clock() - clk;
                if ( Abc_SclCheckOverlap( p->pNtk, vNodes ) )
                    nOverlap++, Vec_IntPush( vTryLater, Abc_ObjId(pObj) );
                else 
                    nChanges += Abc_SclCheckImprovement( p, pObj, vNodes, vEvals, pPars->Notches, pPars->DelayGap );
                nAttempt++;
            }
            Abc_NtkForEachObjVec( vTryLater, pNtk, pObj, k )
                Vec_QuePush( p->vNodeByGain, Abc_ObjId(pObj) );

            clk = Abc_Clock();
            if ( Vec_IntSize(p->vChanged) )
                Abc_SclTimeIncUpdate( p );
            else
                Abc_SclTimeNtkRecompute( p, &p->SumArea, &p->MaxDelay, pPars->fUseDept, pPars->DelayUser );
            p->timeTime += Abc_Clock() - clk;

            p->MaxDelay = Abc_SclReadMaxDelay( p );
            if ( pPars->fUseDept && pPars->DelayUser > 0 && p->MaxDelay < pPars->DelayUser )
                p->MaxDelay = pPars->DelayUser;
            Abc_SclDnsizePrint( p, nRounds++, nAttempt, nOverlap, nChanges, pPars->fVeryVerbose ); 
            nAttemptAll += nAttempt; nOverlapAll += nOverlap; nChangesAll += nChanges;
            if ( nRuntimeLimit && Abc_Clock() > nRuntimeLimit )
                break;
        }
        // recompute
//        Abc_SclTimeNtkRecompute( p, &p->SumArea, &p->MaxDelay, pPars->fUseDept, pPars->DelayUser );
        if ( pPars->fVerbose )
            Abc_SclDnsizePrint( p, -1, nAttemptAll, nOverlapAll, nChangesAll, 1 ); 
        if ( nRuntimeLimit && Abc_Clock() > nRuntimeLimit )
            break;
        if ( nAttemptAll == 0 )
            break;
    }
    Vec_IntFree( vNodes );
    Vec_IntFree( vEvals );
    Vec_IntFree( vTryLater );
    if ( !pPars->fVerbose )
        printf( "                                                                                                                               \r" );

    // report runtime
    p->timeTotal = Abc_Clock() - p->timeTotal;
    if ( pPars->fVerbose )
    {
        p->timeOther = p->timeTotal - p->timeCone - p->timeSize - p->timeTime;
        ABC_PRTP( "Runtime: Critical path", p->timeCone,  p->timeTotal );
        ABC_PRTP( "Runtime: Sizing eval  ", p->timeSize,  p->timeTotal );
        ABC_PRTP( "Runtime: Timing update", p->timeTime,  p->timeTotal );
        ABC_PRTP( "Runtime: Other        ", p->timeOther, p->timeTotal );
        ABC_PRTP( "Runtime: TOTAL        ", p->timeTotal, p->timeTotal );
    }
    if ( pPars->fDumpStats )
        Abc_SclDumpStats( p, "stats2.txt", p->timeTotal );
    if ( nRuntimeLimit && Abc_Clock() > nRuntimeLimit )
        printf( "Gate sizing timed out at %d seconds.\n", pPars->TimeOut );

    // save the result and quit
    Abc_SclSclGates2MioGates( pLib, pNtk ); // updates gate pointers
    Abc_SclManFree( p );
//    Abc_NtkCleanMarkAB( pNtk );
}

static void Abc_SclDumpStats ( SC_Man *  p, char *  pFileName, abctime  Time  )

inlinestatic

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

Synopsis [Dumps timing results into a file.]

Description []

SideEffects []

SeeAlso []

Definition at line 510 of file sclSize.h.

{
    static char FileNameOld[1000] = {0};
    static int nNodesOld, nAreaOld, nDelayOld;
    static abctime clk = 0;
    FILE * pTable;
    pTable = fopen( pFileName, "a+" );
    if ( strcmp( FileNameOld, p->pNtk->pName ) )
    {
        sprintf( FileNameOld, "%s", p->pNtk->pName );
        fprintf( pTable, "\n" );
        fprintf( pTable, "%s ", Extra_FileNameWithoutPath(p->pNtk->pName) );
        fprintf( pTable, "%d ", Abc_NtkPiNum(p->pNtk) );
        fprintf( pTable, "%d ", Abc_NtkPoNum(p->pNtk) );
        fprintf( pTable, "%d ", (nNodesOld = Abc_NtkNodeNum(p->pNtk)) );
        fprintf( pTable, "%d ", (nAreaOld  = (int)p->SumArea)         );
        fprintf( pTable, "%d ", (nDelayOld = (int)p->ReportDelay)     );
        clk = Abc_Clock();
    }
    else
    {
        fprintf( pTable, " " );
        fprintf( pTable, "%.1f ", 100.0 * Abc_NtkNodeNum(p->pNtk) / nNodesOld );
        fprintf( pTable, "%.1f ", 100.0 * (int)p->SumArea         / nAreaOld  );
        fprintf( pTable, "%.1f ", 100.0 * (int)p->ReportDelay     / nDelayOld );
        fprintf( pTable, "%.2f",  1.0*(Abc_Clock() - clk)/CLOCKS_PER_SEC );
    }
    fclose( pTable );
}

static float Abc_SclEvalPerform ( SC_Man *  p, Vec_Int_t *  vCone  )

inlinestatic

Definition at line 376 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    float Diff, Multi = 1.5, Eval = 0;
    int i, k = 0;
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        Diff  = (Vec_FltEntry(p->vTimes3, k++) - Abc_SclObjTime(p, pObj)->rise);
        Diff += (Vec_FltEntry(p->vTimes3, k++) - Abc_SclObjTime(p, pObj)->fall);
        Eval += 0.5 * (Diff > 0 ? Diff : Multi * Diff);
    }
    assert( Vec_FltSize(p->vTimes3) == k );
    return Eval / Vec_IntSize(vCone);
}

static float Abc_SclEvalPerformLegal ( SC_Man *  p, Vec_Int_t *  vCone, float  D  )

inlinestatic

Definition at line 390 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    float Rise, Fall, Multi = 1.0, Eval = 0;
    int i, k = 0;
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        Rise = Vec_FltEntry(p->vTimes3, k++) - Abc_SclObjTime(p, pObj)->rise;
        Fall = Vec_FltEntry(p->vTimes3, k++) - Abc_SclObjTime(p, pObj)->fall;
        if ( Rise + Multi * Abc_SclObjGetSlackR(p, pObj, D) < 0 || Fall + Multi * Abc_SclObjGetSlackF(p, pObj, D) < 0 )
             return -1;
        Eval += 0.5 * Rise + 0.5 * Fall;
    }
    assert( Vec_FltSize(p->vTimes3) == k );
    return Eval / Vec_IntSize(vCone);
}

static void Abc_SclEvalStore ( SC_Man *  p, Vec_Int_t *  vCone  )

inlinestatic

Definition at line 365 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    int i;
    Vec_FltClear( p->vTimes3 );
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        Vec_FltPush( p->vTimes3, Abc_SclObjTime(p, pObj)->rise );
        Vec_FltPush( p->vTimes3, Abc_SclObjTime(p, pObj)->fall );
    }
}

Vec_Int_t* Abc_SclExtractBarBufs

(

Abc_Ntk_t *

pNtk

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 267 of file sclUtil.c.

{
    Vec_Int_t * vBufs;
    Mio_Gate_t * pBuffer;
    Abc_Obj_t * pObj; int i;
    pBuffer = Mio_LibraryReadBuf( (Mio_Library_t *)pNtk->pManFunc );
    if ( pBuffer == NULL )
    {
        printf( "Cannot find buffer in the current library. Quitting.\n" );
        return NULL;
    }
    vBufs = Vec_IntAlloc( 100 );
    Abc_NtkForEachBarBuf( pNtk, pObj, i )
    {
        assert( pObj->pData == NULL );
        pObj->pData = pBuffer;
        Vec_IntPush( vBufs, i );
    }
    return vBufs;
}

Abc_Obj_t* Abc_SclFindCriticalCo	(	SC_Man *	p,
		int *	pfRise
	)

DECLARATIONS ///.

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

FileName [sclSize.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Standard-cell library representation.]

Synopsis [Core timing analysis used in gate-sizing.]

Author [Alan Mishchenko, Niklas Een]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 24, 2012.]

Revision [

Id:

sclSize.c,v 1.0 2012/08/24 00:00:00 alanmi Exp

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

Synopsis [Finding most critical objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 52 of file sclSize.c.

{
    Abc_Obj_t * pObj, * pPivot = NULL;
    float fMaxArr = 0;
    int i;
    assert( Abc_NtkPoNum(p->pNtk) > 0 );
    Abc_NtkForEachCo( p->pNtk, pObj, i )
    {
        SC_Pair * pArr = Abc_SclObjTime( p, pObj );
        if ( fMaxArr < pArr->rise )  fMaxArr = pArr->rise, *pfRise = 1, pPivot = pObj;
        if ( fMaxArr < pArr->fall )  fMaxArr = pArr->fall, *pfRise = 0, pPivot = pObj;
    }
    if ( fMaxArr == 0 )
        pPivot = Abc_NtkPo(p->pNtk, 0);
    assert( pPivot != NULL );
    return pPivot;
}

Abc_Obj_t* Abc_SclFindMostCriticalFanin	(	SC_Man *	p,
		int *	pfRise,
		Abc_Obj_t *	pNode
	)

Definition at line 84 of file sclSize.c.

{
    Abc_Obj_t * pFanin, * pPivot = NULL;
    float fMinSlack = ABC_INFINITY;
    SC_Pair * pArr;
    int i;
    *pfRise = 0;
    // find min-slack node
    Abc_ObjForEachFanin( pNode, pFanin, i )
        if ( fMinSlack > Abc_SclObjGetSlack( p, pFanin, p->MaxDelay0 ) )
        {
            fMinSlack = Abc_SclObjGetSlack( p, pFanin, p->MaxDelay0 );
            pPivot = pFanin;
        }
    if ( pPivot == NULL )
        return NULL;
    // find its leading phase
    pArr = Abc_SclObjTime( p, pPivot );
    *pfRise = (pArr->rise >= pArr->fall);
    return pPivot;
}

Vec_Flt_t* Abc_SclFindWireCaps	(	SC_WireLoad *	pWL,
		int	nFanoutMax
	)

DECLARATIONS ///.

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

FileName [sclLoad.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Standard-cell library representation.]

Synopsis [Wire/gate load computations.]

Author [Alan Mishchenko, Niklas Een]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 24, 2012.]

Revision [

Id:

sclLoad.c,v 1.0 2012/08/24 00:00:00 alanmi Exp

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

Synopsis [Returns estimated wire capacitances for each fanout count.]

Description []

SideEffects []`

SeeAlso []

Definition at line 45 of file sclLoad.c.

{
    Vec_Flt_t * vCaps = NULL;
    float EntryPrev, EntryCur, Slope;
    int i, iPrev, k, Entry, EntryMax;
    assert( pWL != NULL );
    // find the biggest fanout count
    EntryMax = 0;
    Vec_IntForEachEntry( pWL->vFanout, Entry, i )
        EntryMax = Abc_MaxInt( EntryMax, Entry );
    // create the array
    vCaps = Vec_FltStart( Abc_MaxInt(nFanoutMax, EntryMax) + 1 );
    Vec_IntForEachEntry( pWL->vFanout, Entry, i )
        Vec_FltWriteEntry( vCaps, Entry, Vec_FltEntry(pWL->vLen, i) * pWL->cap );
    // interpolate between the values
    assert( Vec_FltEntry(vCaps, 1) != 0 );
    iPrev = 1;
    EntryPrev = Vec_FltEntry(vCaps, 1);
    Vec_FltForEachEntryStart( vCaps, EntryCur, i, 2 )
    {
        if ( EntryCur == 0 )
            continue;
        Slope = (EntryCur - EntryPrev) / (i - iPrev);
        for ( k = iPrev + 1; k < i; k++ )
            Vec_FltWriteEntry( vCaps, k, EntryPrev + Slope * (k - iPrev) );
        EntryPrev = EntryCur;
        iPrev = i;
    }
    // extrapolate after the largest value
    Slope = pWL->cap * pWL->slope;
    for ( k = iPrev + 1; k < i; k++ )
        Vec_FltWriteEntry( vCaps, k, EntryPrev + Slope * (k - iPrev) );
    // show
//    Vec_FltForEachEntry( vCaps, EntryCur, i )
//        printf( "%3d : %f\n", i, EntryCur );
    return vCaps;
}

float Abc_SclFindWireLoad	(	Vec_Flt_t *	vWireCaps,
		int	nFans
	)

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

Synopsis [Computes load for all nodes in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 94 of file sclLoad.c.

{
    if ( vWireCaps == NULL )
        return 0;
    return Vec_FltEntry( vWireCaps, Abc_MinInt(nFans, Vec_FltSize(vWireCaps)-1) );
}

static float Abc_SclGetAverageSize ( Abc_Ntk_t *  pNtk )

inlinestatic

Definition at line 437 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    double Total = 0;
    int i, Count = 0;
    Abc_NtkForEachNode1( pNtk, pObj, i )
        Count++, Total += 100.0*Abc_SclObjCell(pObj)->Order/Abc_SclObjCell(pObj)->nGates;
    return (float)(Total / Count);
}

static int Abc_SclGetBufInvCount ( Abc_Ntk_t *  pNtk )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 429 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    int i, Count = 0;
    Abc_NtkForEachNode( pNtk, pObj, i )
        Count += (Abc_ObjFaninNum(pObj) == 1);
    return Count;
}

static float Abc_SclGetMaxDelay ( SC_Man *  p )

inlinestatic

Definition at line 455 of file sclSize.h.

{
    float fMaxArr = 0;
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachCo( p->pNtk, pObj, i )
        fMaxArr = Abc_MaxFloat( fMaxArr, Abc_SclObjTimeMax(p, pObj) );
    return fMaxArr;
}

static float Abc_SclGetMaxDelayNodeFanins ( SC_Man *  p, Abc_Obj_t *  pNode  )

inlinestatic

Definition at line 464 of file sclSize.h.

{
    float fMaxArr = 0;
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_ObjIsNode(pNode) );
    Abc_ObjForEachFanin( pNode, pObj, i )
        fMaxArr = Abc_MaxFloat( fMaxArr, Abc_SclObjTimeMax(p, pObj) );
    return fMaxArr;
}

static float Abc_SclGetTotalArea ( Abc_Ntk_t *  pNtk )

inlinestatic

Definition at line 446 of file sclSize.h.

{
    double Area = 0;
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachNode1( pNtk, pObj, i )
        Area += Abc_SclObjCell(pObj)->area;
    return Area;
}

void Abc_SclInsertBarBufs	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vBufs
	)

Definition at line 287 of file sclUtil.c.

{
    Abc_Obj_t * pObj; int i;
    Abc_NtkForEachObjVec( vBufs, pNtk, pObj, i )
        pObj->pData = NULL;
}

int Abc_SclIsInv

(

Abc_Obj_t *

pObj

)

Definition at line 116 of file sclBuffer.c.

{
    assert( Abc_ObjIsNode(pObj) );
    return Mio_GateReadTruth((Mio_Gate_t *)pObj->pData) == ABC_CONST(0x5555555555555555);
}

static void Abc_SclLoadRestore ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 301 of file sclSize.h.

{
    Abc_Obj_t * pFanin;
    int i, k = 0;
    Abc_ObjForEachFanin( pObj, pFanin, i )
    {
        Abc_SclObjLoad(p, pFanin)->rise = Vec_FltEntry(p->vLoads2, k++);
        Abc_SclObjLoad(p, pFanin)->fall = Vec_FltEntry(p->vLoads2, k++);
    }
    assert( Vec_FltSize(p->vLoads2) == k );
}

static void Abc_SclLoadRestore3 ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 326 of file sclSize.h.

{
    Abc_Obj_t * pFanin;
    int i, k = 0;
    Abc_SclObjLoad(p, pObj)->rise = Vec_FltEntry(p->vLoads3, k++);
    Abc_SclObjLoad(p, pObj)->fall = Vec_FltEntry(p->vLoads3, k++);
    Abc_ObjForEachFanin( pObj, pFanin, i )
    {
        Abc_SclObjLoad(p, pFanin)->rise = Vec_FltEntry(p->vLoads3, k++);
        Abc_SclObjLoad(p, pFanin)->fall = Vec_FltEntry(p->vLoads3, k++);
    }
    assert( Vec_FltSize(p->vLoads3) == k );
}

static void Abc_SclLoadStore ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

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

Synopsis [Stores/retrivies information for the logic cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 290 of file sclSize.h.

{
    Abc_Obj_t * pFanin;
    int i;
    Vec_FltClear( p->vLoads2 );
    Abc_ObjForEachFanin( pObj, pFanin, i )
    {
        Vec_FltPush( p->vLoads2, Abc_SclObjLoad(p, pFanin)->rise );
        Vec_FltPush( p->vLoads2, Abc_SclObjLoad(p, pFanin)->fall );
    }
}

static void Abc_SclLoadStore3 ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 313 of file sclSize.h.

{
    Abc_Obj_t * pFanin;
    int i;
    Vec_FltClear( p->vLoads3 );
    Vec_FltPush( p->vLoads3, Abc_SclObjLoad(p, pObj)->rise );
    Vec_FltPush( p->vLoads3, Abc_SclObjLoad(p, pObj)->fall );
    Abc_ObjForEachFanin( pObj, pFanin, i )
    {
        Vec_FltPush( p->vLoads3, Abc_SclObjLoad(p, pFanin)->rise );
        Vec_FltPush( p->vLoads3, Abc_SclObjLoad(p, pFanin)->fall );
    }
}

static SC_Man* Abc_SclManAlloc ( SC_Lib *  pLib, Abc_Ntk_t *  pNtk  )

inlinestatic

FUNCTION DEFINITIONS ///.

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

Synopsis [Constructor/destructor of STA manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 147 of file sclSize.h.

{
    SC_Man * p;
    Abc_Obj_t * pObj;
    int i;
    assert( pLib->unit_time == 12 );
    assert( pLib->unit_cap_snd == 15 );
    assert( Abc_NtkHasMapping(pNtk) );
    p = ABC_CALLOC( SC_Man, 1 );
    p->pLib      = pLib;
    p->pNtk      = pNtk;
    p->nObjs     = Abc_NtkObjNumMax(pNtk);
    p->pLoads    = ABC_CALLOC( SC_Pair, p->nObjs );
    p->pDepts    = ABC_CALLOC( SC_Pair, p->nObjs );
    p->pTimes    = ABC_CALLOC( SC_Pair, p->nObjs );
    p->pSlews    = ABC_CALLOC( SC_Pair, p->nObjs );
    p->vBestFans = Vec_IntStart( p->nObjs );
    p->vTimesOut = Vec_FltStart( Abc_NtkCoNum(pNtk) );
    p->vQue      = Vec_QueAlloc( Abc_NtkCoNum(pNtk) );
    Vec_QueSetPriority( p->vQue, Vec_FltArrayP(p->vTimesOut) );
    for ( i = 0; i < Abc_NtkCoNum(pNtk); i++ )
        Vec_QuePush( p->vQue, i );
    p->vUpdates  = Vec_IntAlloc( 1000 );
    p->vUpdates2 = Vec_IntAlloc( 1000 );
    p->vLoads2   = Vec_FltAlloc( 1000 );
    p->vLoads3   = Vec_FltAlloc( 1000 );
    p->vTimes2   = Vec_FltAlloc( 1000 );
    p->vTimes3   = Vec_FltAlloc( 1000 );
    // intermediate data
    p->vNode2Gain  = Vec_FltStart( p->nObjs );
    p->vNode2Gate  = Vec_IntStart( p->nObjs );
    p->vNodeByGain = Vec_QueAlloc( p->nObjs );
    Vec_QueSetPriority( p->vNodeByGain, Vec_FltArrayP(p->vNode2Gain) );
    p->vNodeIter   = Vec_IntStartFull( p->nObjs );
    p->vLevels     = Vec_WecStart( 2 * Abc_NtkLevel(pNtk) + 1 );
    p->vChanged    = Vec_IntAlloc( 100 );
    Abc_NtkForEachCo( pNtk, pObj, i )
        pObj->Level = Abc_ObjFanin0(pObj)->Level + 1;
    // set CI/CO ids
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->iData = i;
    Abc_NtkForEachCo( pNtk, pObj, i )
        pObj->iData = i;
    return p;
}

static void Abc_SclManCleanTime ( SC_Man *  p )

inlinestatic

Definition at line 256 of file sclSize.h.

{
    memset( p->pTimes, 0, sizeof(SC_Pair) * p->nObjs );
    memset( p->pSlews, 0, sizeof(SC_Pair) * p->nObjs );
    memset( p->pDepts, 0, sizeof(SC_Pair) * p->nObjs );
/*
    if ( p->pPiDrive != NULL )
    {
        SC_Pair * pSlew, * pTime, * pLoad;
        Abc_Obj_t * pObj;
        int i;
        Abc_NtkForEachPi( p->pNtk, pObj, i )
        {
            pLoad = Abc_SclObjLoad( p, pObj );
            pTime = Abc_SclObjTime( p, pObj );
            pSlew = Abc_SclObjSlew( p, pObj );
            Scl_LibHandleInputDriver( p->pPiDrive, pLoad, pTime, pSlew );
        }
    }
*/
}

static void Abc_SclManFree ( SC_Man *  p )

inlinestatic

Definition at line 192 of file sclSize.h.

{
    Abc_Obj_t * pObj;
    int i;
    // set CI/CO ids
    Abc_NtkForEachCi( p->pNtk, pObj, i )
        pObj->iData = 0;
    Abc_NtkForEachCo( p->pNtk, pObj, i )
        pObj->iData = 0;
    // other
    p->pNtk->pSCLib = NULL;
    Vec_IntFreeP( &p->pNtk->vGates );
    Vec_IntFreeP( &p->vNodeIter );
    Vec_QueFreeP( &p->vNodeByGain );
    Vec_FltFreeP( &p->vNode2Gain );
    Vec_IntFreeP( &p->vNode2Gate );
    // intermediate data
    Vec_FltFreeP( &p->vLoads2 );
    Vec_FltFreeP( &p->vLoads3 );
    Vec_FltFreeP( &p->vTimes2 );
    Vec_FltFreeP( &p->vTimes3 );
    Vec_IntFreeP( &p->vUpdates );
    Vec_IntFreeP( &p->vUpdates2 );
    Vec_IntFreeP( &p->vGatesBest );
    Vec_WecFreeP( &p->vLevels );
    Vec_IntFreeP( &p->vChanged );
//    Vec_QuePrint( p->vQue );
    Vec_QueCheck( p->vQue );
    Vec_QueFreeP( &p->vQue );
    Vec_FltFreeP( &p->vTimesOut );
    Vec_IntFreeP( &p->vBestFans );
    Vec_FltFreeP( &p->vInDrive );
    Vec_FltFreeP( &p->vWireCaps );
    ABC_FREE( p->pLoads );
    ABC_FREE( p->pDepts );
    ABC_FREE( p->pTimes );
    ABC_FREE( p->pSlews );
    ABC_FREE( p );
}

SC_Man* Abc_SclManStart	(	SC_Lib *	pLib,
		Abc_Ntk_t *	pNtk,
		int	fUseWireLoads,
		int	fDept,
		float	DUser,
		int	nTreeCRatio
	)

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

Synopsis [Prepare timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 633 of file sclSize.c.

{
    SC_Man * p = Abc_SclManAlloc( pLib, pNtk );
    if ( nTreeCRatio )
    {
        p->EstLoadMax = 0.01 * nTreeCRatio;  // max ratio of Cout/Cave when the estimation is used
        p->EstLinear  = 100;                  // linear coefficient
    }
    Abc_SclMioGates2SclGates( pLib, pNtk );
    Abc_SclManReadSlewAndLoad( p, pNtk );
    if ( fUseWireLoads )
    {
        if ( pNtk->pWLoadUsed == NULL )
        {            
            p->pWLoadUsed = Abc_SclFindWireLoadModel( pLib, Abc_SclGetTotalArea(p->pNtk) );
            if ( p->pWLoadUsed )
            pNtk->pWLoadUsed = Abc_UtilStrsav( p->pWLoadUsed->pName );
        }
        else
            p->pWLoadUsed = Abc_SclFetchWireLoadModel( pLib, pNtk->pWLoadUsed );
    }
    Abc_SclTimeNtkRecompute( p, &p->SumArea0, &p->MaxDelay0, fDept, DUser );
    p->SumArea  = p->SumArea0;
    p->MaxDelay = p->MaxDelay0;
    return p;
}

void Abc_SclMinsizePerform	(	SC_Lib *	pLib,
		Abc_Ntk_t *	p,
		int	fUseMax,
		int	fVerbose
	)

Definition at line 185 of file sclUtil.c.

{
    Vec_Int_t * vMinCells;
    Abc_Obj_t * pObj;
    int i, gateId;
    vMinCells = Abc_SclFindMinAreas( pLib, fUseMax );
    Abc_SclMioGates2SclGates( pLib, p );
    Abc_NtkForEachNode1( p, pObj, i )
    {
        gateId = Vec_IntEntry( p->vGates, i );
        assert( gateId >= 0 && gateId < Vec_PtrSize(pLib->vCells) );
        gateId = Vec_IntEntry( vMinCells, gateId );
        assert( gateId >= 0 && gateId < Vec_PtrSize(pLib->vCells) );
        Vec_IntWriteEntry( p->vGates, i, gateId );
    }
    Abc_SclSclGates2MioGates( pLib, p );
    Vec_IntFree( vMinCells );
}

void Abc_SclMioGates2SclGates	(	SC_Lib *	pLib,
		Abc_Ntk_t *	p
	)

DECLARATIONS ///.

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

FileName [sclUtil.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Standard-cell library representation.]

Synopsis [Various utilities.]

Author [Alan Mishchenko, Niklas Een]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 24, 2012.]

Revision [

Id:

sclUtil.c,v 1.0 2012/08/24 00:00:00 alanmi Exp

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

Synopsis [Converts pNode->pData gates into array of SC_Lit gate IDs and back.]

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file sclUtil.c.

{
    Abc_Obj_t * pObj;
    int i, gateId, bufferId;
    // find buffer
    if ( Mio_LibraryReadBuf((Mio_Library_t *)p->pManFunc) == NULL )
    {
        printf( "Cannot find buffer in the current library. Quitting.\n" );
        return;
    }
    bufferId = Abc_SclCellFind( pLib, Mio_GateReadName(Mio_LibraryReadBuf((Mio_Library_t *)p->pManFunc)) );
    assert( bufferId >= 0 );
    // remap cells
    assert( p->vGates == NULL );
    p->vGates = Vec_IntStartFull( Abc_NtkObjNumMax(p) );
    Abc_NtkForEachNode1( p, pObj, i )
    {
        if ( Abc_ObjIsBarBuf(pObj) )
            gateId = bufferId;
        else
            gateId = Abc_SclCellFind( pLib, Mio_GateReadName((Mio_Gate_t *)pObj->pData) );
        assert( gateId >= 0 );
        Vec_IntWriteEntry( p->vGates, i, gateId );
    }
    p->pSCLib = pLib;
}

static SC_Cell* Abc_SclObjCell ( Abc_Obj_t *  p )

inlinestatic

Definition at line 110 of file sclSize.h.

{ int c = Abc_SclObjCellId(p); return c == -1 ? NULL:SC_LibCell(Abc_SclObjLib(p), c); }

static int Abc_SclObjCellId ( Abc_Obj_t *  p )

inlinestatic

Definition at line 109 of file sclSize.h.

{ return Vec_IntEntry( p->pNtk->vGates, Abc_ObjId(p) );                               }

static SC_Pair* Abc_SclObjDept ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 114 of file sclSize.h.

{ return p->pDepts + Abc_ObjId(pObj);  }

static void Abc_SclObjDupFanin ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 127 of file sclSize.h.

{ assert( Abc_ObjIsCo(pObj) ); *Abc_SclObjTime(p, pObj) = *Abc_SclObjTime(p, Abc_ObjFanin0(pObj));  }

static float Abc_SclObjGetSlack ( SC_Man *  p, Abc_Obj_t *  pObj, float  D  )

inlinestatic

Definition at line 125 of file sclSize.h.

{ return D - Abc_MaxFloat(Abc_SclObjTime(p, pObj)->rise + Abc_SclObjDept(p, pObj)->rise, Abc_SclObjTime(p, pObj)->fall + Abc_SclObjDept(p, pObj)->fall);  }

static float Abc_SclObjGetSlackF ( SC_Man *  p, Abc_Obj_t *  pObj, float  D  )

inlinestatic

Definition at line 124 of file sclSize.h.

{ return D - (Abc_SclObjTime(p, pObj)->fall + Abc_SclObjDept(p, pObj)->fall);         }

static float Abc_SclObjGetSlackR ( SC_Man *  p, Abc_Obj_t *  pObj, float  D  )

inlinestatic

Definition at line 123 of file sclSize.h.

{ return D - (Abc_SclObjTime(p, pObj)->rise + Abc_SclObjDept(p, pObj)->rise);         }

static float Abc_SclObjInDrive ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 128 of file sclSize.h.

{ return Vec_FltEntry( p->vInDrive, pObj->iData );                                    }

static SC_Lib* Abc_SclObjLib ( Abc_Obj_t *  p )

inlinestatic

GLOBAL VARIABLES ///.

MACRO DEFINITIONS ///

Definition at line 108 of file sclSize.h.

{ return (SC_Lib *)p->pNtk->pSCLib;    }

static SC_Pair* Abc_SclObjLoad ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 113 of file sclSize.h.

{ return p->pLoads + Abc_ObjId(pObj);  }

static float Abc_SclObjLoadAve ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 119 of file sclSize.h.

{ return 0.5 * Abc_SclObjLoad(p, pObj)->rise + 0.5 * Abc_SclObjLoad(p, pObj)->fall;   }

static double Abc_SclObjLoadMax ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 118 of file sclSize.h.

{ return Abc_MaxFloat(Abc_SclObjLoad(p, pObj)->rise, Abc_SclObjLoad(p, pObj)->fall);  }

static SC_Cell* Abc_SclObjResiable ( SC_Man *  p, Abc_Obj_t *  pObj, int  fUpsize  )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 490 of file sclSize.h.

{
    SC_Cell * pOld = Abc_SclObjCell(pObj);
    if ( fUpsize )
        return pOld->pNext->Order > pOld->Order ? pOld->pNext : NULL;
    else
        return pOld->pPrev->Order < pOld->Order ? pOld->pPrev : NULL;
}

static void Abc_SclObjSetCell ( Abc_Obj_t *  p, SC_Cell *  pCell  )

inlinestatic

Definition at line 111 of file sclSize.h.

{ Vec_IntWriteEntry( p->pNtk->vGates, Abc_ObjId(p), pCell->Id );                      }

static void Abc_SclObjSetInDrive ( SC_Man *  p, Abc_Obj_t *  pObj, float  c  )

inlinestatic

Definition at line 129 of file sclSize.h.

{ Vec_FltWriteEntry( p->vInDrive, pObj->iData, c );                                   }

static double Abc_SclObjSlackMax ( SC_Man *  p, Abc_Obj_t *  pObj, float  D  )

inlinestatic

Definition at line 126 of file sclSize.h.

{ return Abc_SclObjGetSlack(p, pObj, D);                                              }

static SC_Pair* Abc_SclObjSlew ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 116 of file sclSize.h.

{ return p->pSlews + Abc_ObjId(pObj);  }

static double Abc_SclObjSlewMax ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 122 of file sclSize.h.

{ return Abc_MaxFloat(Abc_SclObjSlew(p, pObj)->rise, Abc_SclObjSlew(p, pObj)->fall);  }

static SC_Pair* Abc_SclObjTime ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 115 of file sclSize.h.

{ return p->pTimes + Abc_ObjId(pObj);  }

static float Abc_SclObjTimeMax ( SC_Man *  p, Abc_Obj_t *  pObj  )

inlinestatic

Definition at line 121 of file sclSize.h.

{ return Abc_MaxFloat(Abc_SclObjTime(p, pObj)->rise, Abc_SclObjTime(p, pObj)->fall);  }

static double Abc_SclObjTimeOne ( SC_Man *  p, Abc_Obj_t *  pObj, int  fRise  )

inlinestatic

Definition at line 120 of file sclSize.h.

{ return fRise ? Abc_SclObjTime(p, pObj)->rise : Abc_SclObjTime(p, pObj)->fall;       }

Abc_Ntk_t* Abc_SclPerformBuffering	(	Abc_Ntk_t *	p,
		int	DegreeR,
		int	Degree,
		int	fUseInvs,
		int	fVerbose
	)

Definition at line 457 of file sclBuffer.c.

{
    Vec_Int_t * vCiLevs;
    Abc_Ntk_t * pNew;
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkHasMapping(p) );
    if ( fUseInvs )
    {
        printf( "Warning!!! Using inverters instead of buffers.\n" );
        if ( p->vPhases == NULL )
            printf( "The phases are not given. The result will not verify.\n" );
    }
    // remember CI levels
    vCiLevs = Vec_IntAlloc( Abc_NtkCiNum(p) );
    Abc_NtkForEachCi( p, pObj, i )
        Vec_IntPush( vCiLevs, Abc_ObjLevel(pObj) );
    // perform buffering
    Abc_NtkIncrementTravId( p );        
    Abc_NtkForEachCi( p, pObj, i )
        Abc_SclPerformBuffering_rec( pObj, DegreeR, Degree, fUseInvs, fVerbose );
    // recompute logic levels
    Abc_NtkForEachCi( p, pObj, i )
        pObj->Level = Vec_IntEntry( vCiLevs, i );
    Abc_NtkForEachNode( p, pObj, i )
        Abc_ObjLevelNew( pObj );
    Vec_IntFree( vCiLevs );
    // if phases are present
    if ( p->vPhases )
        Vec_IntFillExtra( p->vPhases, Abc_NtkObjNumMax(p), 0 );
    // duplication in topo order
    pNew = Abc_NtkDupDfs( p );
    Abc_SclCheckNtk( pNew, fVerbose );
//    Abc_NtkDelete( pNew );
    return pNew;
}

void Abc_SclPrintBuffers	(	SC_Lib *	pLib,
		Abc_Ntk_t *	pNtk,
		int	fVerbose
	)

Definition at line 876 of file sclSize.c.

{
    int fUseWireLoads = 0;
    SC_Man * p;
    assert( Abc_NtkIsMappedLogic(pNtk) );
    p = Abc_SclManStart( pLib, pNtk, fUseWireLoads, 1, 0, 10000 ); 
    Abc_SclPrintBufferTrees( p, pNtk ); 
//    Abc_SclPrintFaninPairs( p, pNtk );
    Abc_SclManFree( p );
}

void Abc_SclPrintGateSizes	(	SC_Lib *	pLib,
		Abc_Ntk_t *	p
	)

Definition at line 137 of file sclUtil.c.

{
    Abc_SclMioGates2SclGates( pLib, p );
    Abc_SclManPrintGateSizes( pLib, p, p->vGates );
    Abc_SclSclGates2MioGates( pLib, p );
    Vec_IntFreeP( &p->vGates );
    p->pSCLib = NULL;
}

static float Abc_SclReadMaxDelay ( SC_Man *  p )

inlinestatic

Definition at line 474 of file sclSize.h.

{
    return Abc_SclObjTimeMax( p, Abc_NtkCo(p->pNtk, Vec_QueTop(p->vQue)) );
}

void Abc_SclReportDupFanins

(

Abc_Ntk_t *

pNtk

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Make sure fanins of gates are not duplicated.]

Description []

SideEffects []

SeeAlso []

Definition at line 90 of file sclBuffer.c.

{
    Abc_Obj_t * pObj, * pFanin, * pFanin2;
    int i, k, k2;
    Abc_NtkForEachNode( pNtk, pObj, i )
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Abc_ObjForEachFanin( pObj, pFanin2, k2 )
                if ( k != k2 && pFanin == pFanin2 )
                    printf( "Node %d has dup fanin %d.\n", i, Abc_ObjId(pFanin) );    
}

void Abc_SclSclGates2MioGates	(	SC_Lib *	pLib,
		Abc_Ntk_t *	p
	)

Definition at line 73 of file sclUtil.c.

{
    Abc_Obj_t * pObj;
    SC_Cell * pCell;
    int i, Counter = 0, CounterAll = 0;
    assert( p->vGates != NULL );
    Abc_NtkForEachNode1( p, pObj, i )
    {
        pCell = Abc_SclObjCell(pObj);
        assert( pCell->n_inputs == Abc_ObjFaninNum(pObj) );
        if ( Abc_ObjIsBarBuf(pObj) )
            pObj->pData = NULL;
        else
            pObj->pData = Mio_LibraryReadGateByName( (Mio_Library_t *)p->pManFunc, pCell->pName, NULL );
        Counter += (pObj->pData == NULL);
        assert( pObj->fMarkA == 0 && pObj->fMarkB == 0 );
        CounterAll++;
    }
    if ( Counter )
        printf( "Could not find %d (out of %d) gates in the current library.\n", Counter, CounterAll );
    Vec_IntFreeP( &p->vGates );
    p->pSCLib = NULL;
}

void Abc_SclTimeCone	(	SC_Man *	p,
		Vec_Int_t *	vCone
	)

Definition at line 383 of file sclSize.c.

{
    int fVerbose = 0;
    Abc_Obj_t * pObj;
    int i;
    Abc_SclConeClean( p, vCone );
    Abc_NtkForEachObjVec( vCone, p->pNtk, pObj, i )
    {
        if ( fVerbose && Abc_ObjIsNode(pObj) )
        printf( "  Updating node %d with gate %s\n", Abc_ObjId(pObj), Abc_SclObjCell(pObj)->pName );
        if ( fVerbose && Abc_ObjIsNode(pObj) )
        printf( "    before (%6.1f ps  %6.1f ps)   ", Abc_SclObjTimeOne(p, pObj, 1), Abc_SclObjTimeOne(p, pObj, 0) );
        Abc_SclTimeNode( p, pObj, 0 );
        if ( fVerbose && Abc_ObjIsNode(pObj) )
        printf( "after (%6.1f ps  %6.1f ps)\n", Abc_SclObjTimeOne(p, pObj, 1), Abc_SclObjTimeOne(p, pObj, 0) );
    }
}

void Abc_SclTimeIncInsert	(	SC_Man *	p,
		Abc_Obj_t *	pObj
	)

Definition at line 562 of file sclSize.c.

{
    Vec_IntPush( p->vChanged, Abc_ObjId(pObj) );
}

int Abc_SclTimeIncUpdate

(

SC_Man *

p

)

Definition at line 540 of file sclSize.c.

{
    Abc_Obj_t * pObj;
    int i, RetValue;
    if ( Vec_IntSize(p->vChanged) == 0 )
        return 0;
//    Abc_SclTimeIncCheckLevel( p->pNtk );
    Abc_NtkForEachObjVec( p->vChanged, p->pNtk, pObj, i )
    {
        Abc_SclTimeIncAddFanins( p, pObj );
        if ( pObj->fMarkC )
            continue;
        Abc_SclTimeIncAddNode( p, pObj );
    }
    Vec_IntClear( p->vChanged );
    Abc_SclTimeIncUpdateArrival( p );
    Abc_SclTimeIncUpdateDeparture( p );
    Abc_SclTimeIncUpdateClean( p );
    RetValue = p->nIncUpdates;
    p->nIncUpdates = 0;
    return RetValue;
}

void Abc_SclTimeIncUpdateLevel

(

Abc_Obj_t *

pObj

)

Definition at line 576 of file sclSize.c.

{
    Abc_SclTimeIncUpdateLevel_rec( pObj );
}

void Abc_SclTimeNtkPrint	(	SC_Man *	p,
		int	fShowAll,
		int	fPrintPath
	)

Definition at line 136 of file sclSize.c.

{
    int fReversePath = 1;
    int i, nLength = 0, fRise = 0;
    Abc_Obj_t * pObj, * pPivot = Abc_SclFindCriticalCo( p, &fRise ); 
    float maxDelay = Abc_SclObjTimeOne( p, pPivot, fRise );
    p->ReportDelay = maxDelay;

#ifdef WIN32
    printf( "WireLoad = \"%s\"  ", p->pWLoadUsed ? p->pWLoadUsed->pName : "none" );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 14 ); // yellow
    printf( "Gates =%7d ",         Abc_NtkNodeNum(p->pNtk) );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
    printf( "(%5.1f %%)   ",       100.0 * Abc_SclGetBufInvCount(p->pNtk) / Abc_NtkNodeNum(p->pNtk) );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 10 ); // green
    printf( "Cap =%5.1f ff ",      p->EstLoadAve );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
    printf( "(%5.1f %%)   ",       Abc_SclGetAverageSize(p->pNtk) );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 11 ); // blue
    printf( "Area =%12.2f ",       Abc_SclGetTotalArea(p->pNtk) );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
    printf( "(%5.1f %%)   ",       100.0 * Abc_SclCountMinSize(p->pLib, p->pNtk, 0) / Abc_NtkNodeNum(p->pNtk) );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 13 ); // magenta
    printf( "Delay =%9.2f ps  ",   maxDelay );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
    printf( "(%5.1f %%)   ",       100.0 * Abc_SclCountNearCriticalNodes(p) / Abc_NtkNodeNum(p->pNtk) );
    printf( "            \n" );
#else
    Abc_Print( 1, "WireLoad = \"%s\"  ",   p->pWLoadUsed ? p->pWLoadUsed->pName : "none" );
    Abc_Print( 1, "%sGates =%7d%s ",       "\033[1;33m", Abc_NtkNodeNum(p->pNtk),      "\033[0m" ); // yellow
    Abc_Print( 1, "(%5.1f %%)   ",         100.0 * Abc_SclGetBufInvCount(p->pNtk) / Abc_NtkNodeNum(p->pNtk) );
    Abc_Print( 1, "%sCap =%5.1f ff%s ",    "\033[1;32m", p->EstLoadAve,                "\033[0m" ); // green
    Abc_Print( 1, "(%5.1f %%)   ",         Abc_SclGetAverageSize(p->pNtk) );
    Abc_Print( 1, "%sArea =%12.2f%s ",     "\033[1;36m", Abc_SclGetTotalArea(p->pNtk), "\033[0m" ); // blue
    Abc_Print( 1, "(%5.1f %%)   ",         100.0 * Abc_SclCountMinSize(p->pLib, p->pNtk, 0) / Abc_NtkNodeNum(p->pNtk) );
    Abc_Print( 1, "%sDelay =%9.2f ps%s  ", "\033[1;35m", maxDelay,                     "\033[0m" ); // magenta
    Abc_Print( 1, "(%5.1f %%)   ",         100.0 * Abc_SclCountNearCriticalNodes(p) / Abc_NtkNodeNum(p->pNtk) );
    Abc_Print( 1, "            \n" );
#endif

    if ( fShowAll )
    {
//        printf( "Timing information for all nodes: \n" );
        // find the longest cell name
        Abc_NtkForEachNodeReverse( p->pNtk, pObj, i )
            if ( Abc_ObjFaninNum(pObj) > 0 )
                nLength = Abc_MaxInt( nLength, strlen(Abc_SclObjCell(pObj)->pName) );
        // print timing
        Abc_NtkForEachNodeReverse( p->pNtk, pObj, i )
            if ( Abc_ObjFaninNum(pObj) > 0 )
                Abc_SclTimeNodePrint( p, pObj, -1, nLength, maxDelay );
    }
    if ( fPrintPath )
    {
        Abc_Obj_t * pTemp, * pPrev = NULL;
        int iStart = -1, iEnd = -1;
        Vec_Ptr_t * vPath;
//        printf( "Critical path: \n" );        
        // find the longest cell name
        pObj = Abc_ObjFanin0(pPivot);
        i = 0;
        while ( pObj && Abc_ObjIsNode(pObj) )
        {
            i++;
            nLength = Abc_MaxInt( nLength, strlen(Abc_SclObjCell(pObj)->pName) );
            pObj = Abc_SclFindMostCriticalFanin( p, &fRise, pObj );
        }

        // print timing
        if ( !fReversePath )
        {
            // print timing
            pObj = Abc_ObjFanin0(pPivot);
            while ( pObj )//&& Abc_ObjIsNode(pObj) )
            {
                printf( "Path%3d --", i-- );
                Abc_SclTimeNodePrint( p, pObj, fRise, nLength, maxDelay );
                pPrev = pObj;
                pObj = Abc_SclFindMostCriticalFanin( p, &fRise, pObj );
            }
        }
        else
        {
            // collect path nodes
            vPath = Vec_PtrAlloc( 100 );
            Vec_PtrPush( vPath, pPivot );
            pObj = Abc_ObjFanin0(pPivot);
            while ( pObj )//&& Abc_ObjIsNode(pObj) )
            {
                Vec_PtrPush( vPath, pObj );
                pPrev = pObj;
                pObj = Abc_SclFindMostCriticalFanin( p, &fRise, pObj );
            }
            Vec_PtrForEachEntryReverse( Abc_Obj_t *, vPath, pObj, i )
            {
                printf( "Path%3d --", Vec_PtrSize(vPath)-1-i );
                Abc_SclTimeNodePrint( p, pObj, fRise, nLength, maxDelay );
                if ( i == 1 )
                    break;
            }
            Vec_PtrFree( vPath );
        }
        // print start-point and end-point
        Abc_NtkForEachPi( p->pNtk, pTemp, iStart )
            if ( pTemp == pPrev )
                break;
        Abc_NtkForEachPo( p->pNtk, pTemp, iEnd )
            if ( pTemp == pPivot )
                break;
        printf( "Start-point = pi%0*d.  End-point = po%0*d.\n", 
            Abc_Base10Log( Abc_NtkPiNum(p->pNtk) ), iStart, 
            Abc_Base10Log( Abc_NtkPoNum(p->pNtk) ), iEnd );
    }
}

void Abc_SclTimeNtkRecompute	(	SC_Man *	p,
		float *	pArea,
		float *	pDelay,
		int	fReverse,
		float	DUser
	)

Definition at line 400 of file sclSize.c.

{
    Abc_Obj_t * pObj;
    float D;
    int i;
    Abc_SclComputeLoad( p );
    Abc_SclManCleanTime( p );
    p->nEstNodes = 0;
    Abc_NtkForEachCi( p->pNtk, pObj, i )
        Abc_SclTimeNode( p, pObj, 0 );
    Abc_NtkForEachNode1( p->pNtk, pObj, i )
        Abc_SclTimeNode( p, pObj, 0 );
    Abc_NtkForEachCo( p->pNtk, pObj, i )
        Abc_SclTimeNode( p, pObj, 0 );
    D = Abc_SclReadMaxDelay( p );
    if ( fReverse && DUser > 0 && D < DUser )
        D = DUser;
    if ( pArea )
        *pArea = Abc_SclGetTotalArea(p->pNtk);
    if ( pDelay )
        *pDelay = D;
    if ( fReverse )
    {
        p->nEstNodes = 0;
        Abc_NtkForEachNodeReverse1( p->pNtk, pObj, i )
            Abc_SclTimeNode( p, pObj, 1 );
    }
}

void Abc_SclTimePerform	(	SC_Lib *	pLib,
		Abc_Ntk_t *	pNtk,
		int	nTreeCRatio,
		int	fUseWireLoads,
		int	fShowAll,
		int	fPrintPath,
		int	fDumpStats
	)

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

Synopsis [Printing out timing information for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 671 of file sclSize.c.

{
    SC_Man * p;
    p = Abc_SclManStart( pLib, pNtk, fUseWireLoads, 1, 0, nTreeCRatio );
    Abc_SclTimeNtkPrint( p, fShowAll, fPrintPath );
    if ( fDumpStats )
        Abc_SclDumpStats( p, "stats.txt", 0 );
    Abc_SclManFree( p );
}

Abc_Ntk_t* Abc_SclUnBufferPerform	(	Abc_Ntk_t *	pNtk,
		int	fVerbose
	)

Definition at line 129 of file sclBuffer.c.

{
    Vec_Int_t * vLits;
    Abc_Obj_t * pObj, * pFanin, * pFaninNew;
    int i, k, iLit, nNodesOld = Abc_NtkObjNumMax(pNtk);
    // assign inverters
    vLits = Vec_IntStartFull( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachNode( pNtk, pObj, i )
        if ( Abc_SclIsInv(pObj) && !Abc_SclObjIsBufInv(Abc_ObjFanin0(pObj)) )
            Vec_IntWriteEntry( vLits, Abc_ObjFaninId0(pObj), Abc_ObjId(pObj) );
    // transfer fanins
    Abc_NtkForEachNodeCo( pNtk, pObj, i )
    {
        if ( i >= nNodesOld )
            break;
        Abc_ObjForEachFanin( pObj, pFanin, k )
        {
            if ( !Abc_SclObjIsBufInv(pFanin) )
                continue;
            iLit = Abc_SclGetRealFaninLit( pFanin );
            pFaninNew = Abc_NtkObj( pNtk, Abc_Lit2Var(iLit) );
            if ( Abc_LitIsCompl(iLit) )
            {
                if ( Vec_IntEntry( vLits, Abc_Lit2Var(iLit) ) == -1 )
                {
                    pFaninNew = Abc_NtkCreateNodeInv( pNtk, pFaninNew );
                    Vec_IntWriteEntry( vLits, Abc_Lit2Var(iLit), Abc_ObjId(pFaninNew) );
                }
                else
                    pFaninNew = Abc_NtkObj( pNtk, Vec_IntEntry( vLits, Abc_Lit2Var(iLit) ) );
                assert( Abc_ObjFaninNum(pFaninNew) == 1 );
            }
            if ( pFanin != pFaninNew )
                Abc_ObjPatchFanin( pObj, pFanin, pFaninNew );
        }
    }
    Vec_IntFree( vLits );
    // duplicate network in topo order
    return Abc_NtkDupDfs( pNtk );
}

Abc_Ntk_t* Abc_SclUnBufferPhase	(	Abc_Ntk_t *	pNtk,
		int	fVerbose
	)

Definition at line 239 of file sclBuffer.c.

{
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pFanin, * pFaninNew;
    int i, k, iLit, Counter = 0, Total = 0;
    assert( pNtk->vPhases == NULL );
    pNtk->vPhases = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachNodeCo( pNtk, pObj, i )
    {
        if ( Abc_SclObjIsBufInv(pObj) )
            continue;
        Abc_ObjForEachFanin( pObj, pFanin, k )
        {
            Total++;
            iLit = Abc_SclGetRealFaninLit( pFanin );
            pFaninNew = Abc_NtkObj( pNtk, Abc_Lit2Var(iLit) );
            if ( pFaninNew == pFanin )
                continue;
            // skip fanins which are already fanins of the node
            if ( Abc_NodeFindFanin( pObj, pFaninNew ) >= 0 )
                continue;
            Abc_ObjPatchFanin( pObj, pFanin, pFaninNew );
            if ( Abc_LitIsCompl(iLit) )
                Abc_ObjFaninFlipPhase( pObj, k ), Counter++;
        }
    }
    if ( fVerbose )
        printf( "Saved %d (%.2f %%) fanin phase bits.  ", Counter, 100.0 * Counter / Total );
    // duplicate network in topo order
    pNtkNew = Abc_NtkDupDfs( pNtk );
    if ( fVerbose )
        printf( "Max depth = %d.\n", Abc_SclCountMaxPhases(pNtkNew) );
    Abc_SclReportDupFanins( pNtkNew );
    return pNtkNew;
}

void Abc_SclUpdateLoad	(	SC_Man *	p,
		Abc_Obj_t *	pObj,
		SC_Cell *	pOld,
		SC_Cell *	pNew
	)

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

Synopsis [Updates load of the node's fanins.]

Description []

SideEffects []

SeeAlso []

Definition at line 199 of file sclLoad.c.

{
    Abc_Obj_t * pFanin;
    int k;
    Abc_ObjForEachFanin( pObj, pFanin, k )
    {
        SC_Pair * pLoad = Abc_SclObjLoad( p, pFanin );
        SC_Pin * pPinOld = SC_CellPin( pOld, k );
        SC_Pin * pPinNew = SC_CellPin( pNew, k );
        pLoad->rise += pPinNew->rise_cap - pPinOld->rise_cap;
        pLoad->fall += pPinNew->fall_cap - pPinOld->fall_cap;
    }
}

void Abc_SclUpdateLoadSplit	(	SC_Man *	p,
		Abc_Obj_t *	pBuffer,
		Abc_Obj_t *	pFanout
	)

Definition at line 212 of file sclLoad.c.

{
    SC_Pin * pPin;
    SC_Pair * pLoad;
    int iFanin = Abc_NodeFindFanin( pFanout, pBuffer );
    assert( iFanin >= 0 );
    assert( Abc_ObjFaninNum(pBuffer) == 1 );
    pPin = SC_CellPin( Abc_SclObjCell(pFanout), iFanin );
    // update load of the buffer
    pLoad = Abc_SclObjLoad( p, pBuffer );
    pLoad->rise -= pPin->rise_cap;
    pLoad->fall -= pPin->fall_cap;
    // update load of the fanin
    pLoad = Abc_SclObjLoad( p, Abc_ObjFanin0(pBuffer) );
    pLoad->rise += pPin->rise_cap;
    pLoad->fall += pPin->fall_cap;
}

void Abc_SclUpsizePerform	(	SC_Lib *	pLib,
		Abc_Ntk_t *	pNtk,
		SC_SizePars *	pPars
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 868 of file sclUpsize.c.

{
    SC_Man * p;
    Vec_Int_t * vPathPos = NULL;    // critical POs
    Vec_Int_t * vPathNodes = NULL;  // critical nodes and PIs
    abctime clk, nRuntimeLimit = pPars->TimeOut ? pPars->TimeOut * CLOCKS_PER_SEC + Abc_Clock() : 0;
    int i = 0, win, nUpsizes = -1, nFramesNoChange = 0, nConeSize = 0;
    int nAllPos, nAllNodes, nAllTfos, nAllUpsizes;
    if ( pPars->fVerbose )
    {
        printf( "Parameters: " );
        printf( "Iters =%5d.  ",          pPars->nIters   );
        printf( "Time win =%3d %%. ",     pPars->Window   );
        printf( "Update ratio =%3d %%. ", pPars->Ratio    );
        printf( "UseDept =%2d. ",         pPars->fUseDept );
        printf( "UseWL =%2d. ",           pPars->fUseWireLoads );
        printf( "Target =%5d ps. ",       pPars->DelayUser );
        printf( "DelayGap =%3d ps. ",     pPars->DelayGap );
        printf( "Timeout =%4d sec",       pPars->TimeOut  );
        printf( "\n" );
    }
    // increase window for larger networks
    if ( pPars->Window == 1 )
        pPars->Window += (Abc_NtkNodeNum(pNtk) > 40000);
    // prepare the manager; collect init stats
    p = Abc_SclManStart( pLib, pNtk, pPars->fUseWireLoads, pPars->fUseDept, 0, pPars->BuffTreeEst );
    p->timeTotal  = Abc_Clock();
    assert( p->vGatesBest == NULL );
    p->vGatesBest = Vec_IntDup( p->pNtk->vGates );
    p->BestDelay  = p->MaxDelay0;
    // perform upsizing
    nAllPos = nAllNodes = nAllTfos = nAllUpsizes = 0;
    if ( p->BestDelay <= pPars->DelayUser )
        printf( "Current delay (%.2f ps) does not exceed the target delay (%.2f ps). Upsizing is not performed.\n", p->BestDelay, (float)pPars->DelayUser );
    else
    for ( i = 0; i < pPars->nIters; i++ )
    {
        for ( win = pPars->Window + ((i % 7) == 6); win <= 100;  win *= 2 )
        {
            // detect critical path
            clk = Abc_Clock();
            vPathPos   = Abc_SclFindCriticalCoWindow( p, win );
            vPathNodes = Abc_SclFindCriticalNodeWindow( p, vPathPos, win, pPars->fUseDept );
            p->timeCone += Abc_Clock() - clk;

            // selectively upsize the nodes
            clk = Abc_Clock();
            if ( pPars->BypassFreq && i && (i % pPars->BypassFreq) == 0 )
                nUpsizes = Abc_SclFindBypasses( p, vPathNodes, pPars->Ratio, pPars->Notches, i, pPars->DelayGap, pPars->fVeryVerbose );
            else
                nUpsizes = Abc_SclFindUpsizes( p, vPathNodes, pPars->Ratio, pPars->Notches, i, pPars->DelayGap, (pPars->BypassFreq > 0) );
            p->timeSize += Abc_Clock() - clk;

            // unmark critical path
            clk = Abc_Clock();
            Abc_SclUnmarkCriticalNodeWindow( p, vPathNodes );
            Abc_SclUnmarkCriticalNodeWindow( p, vPathPos );
            p->timeCone += Abc_Clock() - clk;
            if ( nUpsizes > 0 )
                break;
            Vec_IntFree( vPathPos );
            Vec_IntFree( vPathNodes );
        }
        if ( nUpsizes == 0 )
            break;

        // update timing information
        clk = Abc_Clock();
        if ( pPars->fUseDept )
        {
            if ( Vec_IntSize(p->vChanged) && !(pPars->BypassFreq && i && (i % pPars->BypassFreq) == 0) )
                nConeSize = Abc_SclTimeIncUpdate( p );
            else
                Abc_SclTimeNtkRecompute( p, NULL, NULL, pPars->fUseDept, 0 );
        }
        else
        {
            Vec_Int_t * vTFO = Abc_SclFindTFO( p->pNtk, vPathNodes );
            Abc_SclTimeCone( p, vTFO );
            nConeSize = Vec_IntSize( vTFO );
            Vec_IntFree( vTFO );
        }
        p->timeTime += Abc_Clock() - clk;
//        Abc_SclUpsizePrintDiffs( p, pLib, pNtk );

        // save the best network
        p->MaxDelay = Abc_SclReadMaxDelay( p );
        if ( p->BestDelay > p->MaxDelay )
        {
            p->BestDelay = p->MaxDelay;
            Abc_SclApplyUpdateToBest( p->vGatesBest, p->pNtk->vGates, p->vUpdates );
            Vec_IntClear( p->vUpdates2 );
            nFramesNoChange = 0;
        }
        else
            nFramesNoChange++;

        // report and cleanup
        Abc_SclUpsizePrint( p, i, win, Vec_IntSize(vPathPos), Vec_IntSize(vPathNodes), nUpsizes, nConeSize, pPars->fVeryVerbose || (pPars->fVerbose && nFramesNoChange == 0) ); //|| (i == nIters-1) );
        nAllPos     += Vec_IntSize(vPathPos);
        nAllNodes   += Vec_IntSize(vPathNodes);
        nAllTfos    += nConeSize;
        nAllUpsizes += nUpsizes;
        Vec_IntFree( vPathPos );
        Vec_IntFree( vPathNodes );
        // check timeout
        if ( nRuntimeLimit && Abc_Clock() > nRuntimeLimit )
            break;
        // check no change
        if ( nFramesNoChange > pPars->nIterNoChange )
            break;
        // check best delay
        if ( p->BestDelay <= pPars->DelayUser )
            break;
    }
    // update for best gates and recompute timing
    ABC_SWAP( Vec_Int_t *, p->vGatesBest, p->pNtk->vGates );
    if ( pPars->BypassFreq != 0 )
        Abc_SclUndoRecentChanges( p->pNtk, p->vUpdates2 );
    if ( pPars->BypassFreq != 0 )
        Abc_SclUpsizeRemoveDangling( p, pNtk );
    Abc_SclTimeNtkRecompute( p, &p->SumArea, &p->MaxDelay, 0, 0 );
    if ( pPars->fVerbose )
        Abc_SclUpsizePrint( p, i, pPars->Window, nAllPos/(i?i:1), nAllNodes/(i?i:1), nAllUpsizes/(i?i:1), nAllTfos/(i?i:1), 1 );
    else
        printf( "                                                                                                                                                  \r" );
    // report runtime
    p->timeTotal = Abc_Clock() - p->timeTotal;
    if ( pPars->fVerbose )
    {
        p->timeOther = p->timeTotal - p->timeCone - p->timeSize - p->timeTime;
        ABC_PRTP( "Runtime: Critical path", p->timeCone,  p->timeTotal );
        ABC_PRTP( "Runtime: Sizing eval  ", p->timeSize,  p->timeTotal );
        ABC_PRTP( "Runtime: Timing update", p->timeTime,  p->timeTotal );
        ABC_PRTP( "Runtime: Other        ", p->timeOther, p->timeTotal );
        ABC_PRTP( "Runtime: TOTAL        ", p->timeTotal, p->timeTotal );
    }
    if ( pPars->fDumpStats )
        Abc_SclDumpStats( p, "stats2.txt", p->timeTotal );
    if ( nRuntimeLimit && Abc_Clock() > nRuntimeLimit )
        printf( "Gate sizing timed out at %d seconds.\n", pPars->TimeOut );

    // save the result and quit
    Abc_SclSclGates2MioGates( pLib, pNtk ); // updates gate pointers
    Abc_SclManFree( p );
//    Abc_NtkCleanMarkAB( pNtk );
}