sclSize.h File Reference

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

Include dependency graph for sclSize.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SC_Man_

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct SC_Man_	SC_Man
	INCLUDES ///.

Functions
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 ///.
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, void *pFuncFanin)
Vec_Flt_t *	Abc_SclFindWireCaps (SC_WireLoad *pWL, int nFanoutMax)
	DECLARATIONS ///.
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 ///.
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 *pFuncFanin)
void	Abc_SclMioGates2SclGates (SC_Lib *pLib, Abc_Ntk_t *p)
	DECLARATIONS ///.
void	Abc_SclSclGates2MioGates (SC_Lib *pLib, Abc_Ntk_t *p)
void	Abc_SclTransferGates (Abc_Ntk_t *pOld, Abc_Ntk_t *pNew)
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

SC_Man

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

Abc_NodeInvUpdateFanPolarity()

void Abc_NodeInvUpdateFanPolarity ( Abc_Obj_t * pObj )

extern

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 322 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) );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodeInvUpdateObjFanoutPolarity()

void Abc_NodeInvUpdateObjFanoutPolarity ( Abc_Obj_t * pObj, Abc_Obj_t * pFanout )

extern

Definition at line 336 of file sclBuffer.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclAddWireLoad()

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

extern

Definition at line 102 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclBufferingPerform()

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

extern

Definition at line 491 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;
}

Here is the call graph for this function:

Abc_SclBufferPhase()

Abc_Ntk_t * Abc_SclBufferPhase ( Abc_Ntk_t * pNtk, int fVerbose )

extern

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;
}

Here is the call graph for this function:

Abc_SclBufPerform()

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

extern

Definition at line 986 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;
}

Here is the call graph for this function:

Abc_SclCheckNtk()

int Abc_SclCheckNtk ( Abc_Ntk_t * p, int fVerbose )

extern

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_ObjIsBarBuf(pObj) )
            continue;
        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;
}

Here is the caller graph for this function:

Abc_SclComputeLoad()

void Abc_SclComputeLoad ( SC_Man * p )

extern

Definition at line 108 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 );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclCountMinSize()

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

extern

Definition at line 222 of file sclUtil.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclCountNearCriticalNodes()

int Abc_SclCountNearCriticalNodes ( SC_Man * p )

extern

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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclDnsizePerform()

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

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 361 of file sclDnsize.c.

{
    Abc_Ntk_t * pNtkNew = pNtk;
    if ( pNtk->nBarBufs2 > 0 )
        pNtkNew = Abc_NtkDupDfsNoBarBufs( pNtk );
    Abc_SclDnsizePerformInt( pLib, pNtkNew, pPars, pFuncFanin );
    if ( pNtk->nBarBufs2 > 0 )
        Abc_SclTransferGates( pNtk, pNtkNew );
    if ( pNtk->nBarBufs2 > 0 )
        Abc_NtkDelete( pNtkNew );
}

Here is the call graph for this function:

Abc_SclExtractBarBufs()

Vec_Int_t * Abc_SclExtractBarBufs ( Abc_Ntk_t * pNtk )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 287 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;
}

Here is the call graph for this function:

Abc_SclFindCriticalCo()

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

extern

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;
}

Here is the caller graph for this function:

Abc_SclFindMostCriticalFanin()

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

extern

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;
}

Here is the caller graph for this function:

Abc_SclFindWireCaps()

Vec_Flt_t * Abc_SclFindWireCaps ( SC_WireLoad * pWL, int nFanoutMax )

extern

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 );
    if ( Vec_FltEntry(vCaps, 1) == 0 )
        return vCaps;
    // 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;
}

Here is the caller graph for this function:

Abc_SclFindWireLoad()

float Abc_SclFindWireLoad ( Vec_Flt_t * vWireCaps, int nFans )

extern

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 96 of file sclLoad.c.

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

Here is the caller graph for this function:

Abc_SclInsertBarBufs()

void Abc_SclInsertBarBufs ( Abc_Ntk_t * pNtk, Vec_Int_t * vBufs )

extern

Definition at line 307 of file sclUtil.c.

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

Abc_SclIsInv()

int Abc_SclIsInv ( Abc_Obj_t * pObj )

extern

Definition at line 116 of file sclBuffer.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclManStart()

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

extern

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

Synopsis [Prepare timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 648 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclMinsizePerform()

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

extern

Definition at line 204 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_NtkForEachNodeNotBarBuf1( 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 );
}

Here is the call graph for this function:

Abc_SclMioGates2SclGates()

void Abc_SclMioGates2SclGates ( SC_Lib * pLib, Abc_Ntk_t * p )

extern

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_NtkForEachNodeNotBarBuf1( p, pObj, i )
    {
        gateId = Abc_SclCellFind( pLib, Mio_GateReadName((Mio_Gate_t *)pObj->pData) );
        assert( gateId >= 0 );
        Vec_IntWriteEntry( p->vGates, i, gateId );
    }
    p->pSCLib = pLib;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclPerformBuffering()

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

extern

Definition at line 459 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;
}

Here is the call graph for this function:

Abc_SclPrintBuffers()

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

extern

Definition at line 912 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 );
}

Here is the call graph for this function:

Abc_SclPrintGateSizes()

void Abc_SclPrintGateSizes ( SC_Lib * pLib, Abc_Ntk_t * p )

extern

Definition at line 156 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;
}

Here is the call graph for this function:

Abc_SclReportDupFanins()

void Abc_SclReportDupFanins ( Abc_Ntk_t * pNtk )

extern

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) );    
}

Here is the caller graph for this function:

Abc_SclSclGates2MioGates()

void Abc_SclSclGates2MioGates ( SC_Lib * pLib, Abc_Ntk_t * p )

extern

Definition at line 70 of file sclUtil.c.

{
    Abc_Obj_t * pObj;
    SC_Cell * pCell;
    int i, Counter = 0, CounterAll = 0;
    assert( p->vGates != NULL );
    Abc_NtkForEachNodeNotBarBuf1( p, pObj, i )
    {
        pCell = Abc_SclObjCell(pObj);
        assert( pCell->n_inputs == Abc_ObjFaninNum(pObj) );
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclTimeCone()

void Abc_SclTimeCone ( SC_Man * p, Vec_Int_t * vCone )

extern

Definition at line 398 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) );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclTimeIncInsert()

void Abc_SclTimeIncInsert ( SC_Man * p, Abc_Obj_t * pObj )

extern

Definition at line 577 of file sclSize.c.

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

Here is the caller graph for this function:

Abc_SclTimeIncUpdate()

int Abc_SclTimeIncUpdate ( SC_Man * p )

extern

Definition at line 555 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;
}

Here is the caller graph for this function:

Abc_SclTimeIncUpdateLevel()

void Abc_SclTimeIncUpdateLevel ( Abc_Obj_t * pObj )

extern

Definition at line 591 of file sclSize.c.

{
    Abc_SclTimeIncUpdateLevel_rec( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclTimeNtkPrint()

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

extern

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;
    // used for Floyds cycle detection algorithm
    unsigned int tortoiseIndex = 0;
    int tortoiseStep = 0;
 
#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, Abc_SclObjCell(pObj) ? strlen(Abc_SclObjCell(pObj)->pName) : 2 /* strlen("pi") */ );
            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 );
 
                // move the tortoise at half the speed (trailing)
                tortoiseStep = (tortoiseStep + 1) % 2;
                tortoiseIndex += tortoiseStep;
                // if they see the same element, we are in a loop
                if(vPath->pArray[tortoiseIndex] == pObj) {
                    break;
                }
            }
            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 );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclTimeNtkRecompute()

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

extern

Definition at line 415 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 );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclTimePerform()

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

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 707 of file sclSize.c.

{
    Abc_Ntk_t * pNtkNew = pNtk;
    if ( pNtk->nBarBufs2 > 0 )
        pNtkNew = Abc_NtkDupDfsNoBarBufs( pNtk );
    Abc_SclTimePerformInt( pLib, pNtkNew, nTreeCRatio, fUseWireLoads, fShowAll, fPrintPath, fDumpStats );
    if ( pNtk->nBarBufs2 > 0 )
        Abc_NtkDelete( pNtkNew );
}

Here is the call graph for this function:

Abc_SclTransferGates()

void Abc_SclTransferGates ( Abc_Ntk_t * pOld, Abc_Ntk_t * pNew )

extern

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

Synopsis [Transfer gate sizes from AIG without barbufs.]

Description []

SideEffects []

SeeAlso []

Definition at line 102 of file sclUtil.c.

{
    Abc_Obj_t * pObj; int i;
    assert( pOld->nBarBufs2 > 0 );
    assert( pNew->nBarBufs2 == 0 );
    Abc_NtkForEachNodeNotBarBuf( pOld, pObj, i )
    {
        if ( pObj->pCopy == NULL )
            continue;
        assert( Abc_ObjNtk(pObj->pCopy) == pNew );
        pObj->pData = pObj->pCopy->pData;
    }
}

Here is the caller graph for this function:

Abc_SclUnBufferPerform()

Abc_Ntk_t * Abc_SclUnBufferPerform ( Abc_Ntk_t * pNtk, int fVerbose )

extern

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 );
}

Here is the call graph for this function:

Abc_SclUnBufferPhase()

Abc_Ntk_t * Abc_SclUnBufferPhase ( Abc_Ntk_t * pNtk, int fVerbose )

extern

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;
}

Here is the call graph for this function:

Abc_SclUpdateLoad()

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

extern

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 201 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;
    }
}

Here is the caller graph for this function:

Abc_SclUpdateLoadSplit()

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

extern

Definition at line 214 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_SclUpsizePerform()

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

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1028 of file sclUpsize.c.

{
    Abc_Ntk_t * pNtkNew = pNtk;
    if ( pNtk->nBarBufs2 > 0 )
        pNtkNew = Abc_NtkDupDfsNoBarBufs( pNtk );
    Abc_SclUpsizePerformInt( pLib, pNtkNew, pPars, pFuncFanin );
    if ( pNtk->nBarBufs2 > 0 )
        Abc_SclTransferGates( pNtk, pNtkNew );
    if ( pNtk->nBarBufs2 > 0 )
        Abc_NtkDelete( pNtkNew );
}

Here is the call graph for this function: