wlnRetime.c File Reference

#include "wln.h"
#include "misc/vec/vecHsh.h"

Include dependency graph for wlnRetime.c:

Go to the source code of this file.

Classes
struct	Wln_Ret_t_

Macros
#define	Wln_RetForEachFanin(p, iObj, iFanin, pLink, i)
#define	Wln_RetForEachFanout(p, iObj, iFanout, pLink, i)

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Wln_Ret_t_	Wln_Ret_t
	DECLARATIONS ///.

Functions
void	Wln_RetPrintObj (Wln_Ret_t *p, int iObj)
	FUNCTION DEFINITIONS ///.
void	Wln_RetPrint (Wln_Ret_t *p, int fVerbose)
int	Wln_RetComputeFfClasses (Wln_Ntk_t *pNtk, Vec_Int_t *vClasses)
Wln_Ret_t *	Wln_RetAlloc (Wln_Ntk_t *pNtk)
void	Wln_RetFree (Wln_Ret_t *p)
int	Wln_RetMemUsage (Wln_Ret_t *p)
void	Wln_RetMarkChanges_rec (Wln_Ret_t *p, int iObj)
void	Wln_RetMarkChanges (Wln_Ret_t *p, Vec_Int_t *vFront)
int	Wln_RetPropDelay_rec (Wln_Ret_t *p, int iObj)
int	Wln_RetPropDelay (Wln_Ret_t *p)
void	Wln_RetFindSources_rec (Wln_Ret_t *p, int iObj)
void	Wln_RetFindSources (Wln_Ret_t *p)
int	Wln_RetMarkPaths_rec (Wln_Ntk_t *p, int iObj, int fVerbose)
void	Wln_RetMarkPaths (Wln_Ntk_t *p, int fVerbose)
int *	Wln_RetHeadToTail (Wln_Ret_t *p, int *pHead)
int	Wln_RetCheckForward (Wln_Ret_t *p, Vec_Int_t *vSet)
int	Wln_RetCheckBackward (Wln_Ret_t *p, Vec_Int_t *vSet)
int	Wln_RetRemoveOneFanin (Wln_Ret_t *p, int iObj)
int	Wln_RetRemoveOneFanout (Wln_Ret_t *p, int iObj)
void	Wln_RetInsertOneFanin (Wln_Ret_t *p, int iObj, int iFlop)
void	Wln_RetInsertOneFanout (Wln_Ret_t *p, int iObj, int iFlop)
void	Wln_RetRetimeForward (Wln_Ret_t *p, Vec_Int_t *vSet)
void	Wln_RetRetimeBackward (Wln_Ret_t *p, Vec_Int_t *vSet)
void	Wln_RetAddToMoves (Wln_Ret_t *p, Vec_Int_t *vSet, int Delay, int fForward, int nMoves, int fSkipSimple, int fVerbose)
void	Wln_NtkRetimeCreateDelayInfo (Wln_Ntk_t *pNtk)
Vec_Int_t *	Wln_NtkRetime_int (Wln_Ntk_t *pNtk, int fSkipSimple, int fVerbose)
Vec_Int_t *	Wln_NtkRetime (Wln_Ntk_t *pNtk, int fIgnoreIO, int fSkipSimple, int fVerbose)

Macro Definition Documentation

Wln_RetForEachFanin

#define Wln_RetForEachFanin	(		p,
			iObj,
			iFanin,
			pLink,
			i )

Value:

    for ( i = 0; (i < Wln_ObjFaninNum(p->pNtk, iObj)) &&    \
         (((iFanin) = Wln_RetFanins(p, iObj)[2*i]), 1) &&   \
           ((pLink) = (Wln_RetFanins(p, iObj)+2*i+1)); i++ ) if ( !iFanin || (!Wln_ObjFaninNum(p->pNtk, iFanin) && !Wln_ObjIsCi(p->pNtk, iFanin)) )  {} else

Definition at line 51 of file wlnRetime.c.

#define Wln_RetForEachFanin( p, iObj, iFanin, pLink, i )    \
    for ( i = 0; (i < Wln_ObjFaninNum(p->pNtk, iObj)) &&    \
         (((iFanin) = Wln_RetFanins(p, iObj)[2*i]), 1) &&   \
           ((pLink) = (Wln_RetFanins(p, iObj)+2*i+1)); i++ ) if ( !iFanin || (!Wln_ObjFaninNum(p->pNtk, iFanin) && !Wln_ObjIsCi(p->pNtk, iFanin)) )  {} else

Wln_RetForEachFanout

#define Wln_RetForEachFanout	(		p,
			iObj,
			iFanout,
			pLink,
			i )

Value:

    for ( i = 0; (i < Wln_ObjRefs(p->pNtk, iObj)) &&        \
        (((iFanout) = Wln_RetFanouts(p, iObj)[2*i]), 1) &&  \
           ((pLink) = Vec_IntEntryP(&p->vFanins, Wln_RetFanouts(p, iObj)[2*i+1])); i++ ) if ( !iFanout ) {} else

Definition at line 56 of file wlnRetime.c.

#define Wln_RetForEachFanout( p, iObj, iFanout, pLink, i )  \
    for ( i = 0; (i < Wln_ObjRefs(p->pNtk, iObj)) &&        \
        (((iFanout) = Wln_RetFanouts(p, iObj)[2*i]), 1) &&  \
           ((pLink) = Vec_IntEntryP(&p->vFanins, Wln_RetFanouts(p, iObj)[2*i+1])); i++ ) if ( !iFanout ) {} else

Typedef Documentation

Wln_Ret_t

typedef typedefABC_NAMESPACE_IMPL_START struct Wln_Ret_t_ Wln_Ret_t

DECLARATIONS ///.

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

FileName [wlnRetime.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis [Retiming.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 23, 2018.]

Revision [

Id

wlnRetime.c,v 1.00 2018/09/23 00:00:00 alanmi Exp

]

Definition at line 30 of file wlnRetime.c.

Function Documentation

Wln_NtkRetime()

Vec_Int_t * Wln_NtkRetime	(	Wln_Ntk_t *	pNtk,
		int	fIgnoreIO,
		int	fSkipSimple,
		int	fVerbose )

Definition at line 718 of file wlnRetime.c.

{
    if ( fIgnoreIO )
        Wln_RetMarkPaths( pNtk, fVerbose );
    return Wln_NtkRetime_int( pNtk, fSkipSimple, fVerbose );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkRetime_int()

Vec_Int_t * Wln_NtkRetime_int	(	Wln_Ntk_t *	pNtk,
		int	fSkipSimple,
		int	fVerbose )

Definition at line 623 of file wlnRetime.c.

{
    Wln_Ret_t * p = Wln_RetAlloc( pNtk );
    Vec_Int_t * vSources = &p->vSources;
    Vec_Int_t * vSinks   = &p->vSinks;
    Vec_Int_t * vFront   = &p->vFront;
    Vec_Int_t * vMoves   = Vec_IntAlloc(0);
    int nMoves = 0, fPrevFwd = 0, fPrevBwd = 0, nCountIncrease = 0;
    int DelayInit = 0, DelayBest = 0, nChange = 0;
    Wln_RetPrint( p, fVerbose );
    Wln_RetMarkChanges( p, NULL );
    p->DelayMax = DelayInit = DelayBest = Wln_RetPropDelay( p );
    Wln_RetFindSources( p );
    Wln_RetAddToMoves( p, NULL, p->DelayMax, 0, nMoves, fSkipSimple, fVerbose );
    while ( Vec_IntSize(vSources) || Vec_IntSize(vSinks) )
    {
        int DelayMaxPrev = p->DelayMax;
        int fForward  = Vec_IntSize(vSources) && Wln_RetCheckForward( p, vSources );
        int fBackward = Vec_IntSize(vSinks)   && Wln_RetCheckBackward( p, vSinks );
        Vec_IntSort( vSources, 0 );
        Vec_IntSort( vSinks, 0 );
 
        if ( !fForward && !fBackward )
        {
            printf( "Cannot retime forward and backward.\n" );
            break;
        }
        if ( Vec_IntTwoCountCommon(vSources, vSinks) )
        {
            printf( "Cannot reduce delay by retiming.\n" );
            break;
        }
        nMoves++;
        Vec_IntClear( vFront );
        if ( (fPrevFwd && fForward) || (!(fPrevBwd && fBackward) && ((fForward && !fBackward) || (fForward && fBackward && Vec_IntSize(vSources) < Vec_IntSize(vSinks)))) )
        {
            Vec_IntAppend( vFront, vSources );
            Wln_RetMarkChanges( p, vFront );
            Wln_RetRetimeForward( p, vFront );
            p->DelayMax = Wln_RetPropDelay( p );
            fForward = 1, fBackward = 0;
            fPrevFwd = 1;
        }
        else
        {
            Vec_IntAppend( vFront, vSinks );
            Wln_RetRetimeBackward( p, vFront );
            Wln_RetMarkChanges( p, vFront );
            p->DelayMax = Wln_RetPropDelay( p );
            fForward = 0, fBackward = 1;
            fPrevBwd = 1;
        }
        DelayBest = Abc_MinInt( DelayBest, p->DelayMax );
        //Wln_RetPrint( p );
        if ( fVerbose )
            printf( "\n" );
        Wln_RetAddToMoves( p, vFront, p->DelayMax, fForward, nMoves, fSkipSimple, fVerbose );
        if ( fVerbose )
        {
            printf( "Sinks: " );
            Vec_IntPrint( &p->vSinks );
            printf( "Sources: " );
            Vec_IntPrint( &p->vSources );
        }
        if ( p->DelayMax >= DelayMaxPrev )
            nCountIncrease++;
        else
        {
            if ( nCountIncrease > 0 )
                nChange++;
            nCountIncrease = 0;
        }
        if ( nCountIncrease > 3 )
            break;
        if ( nChange > 5 )
            break;
        Wln_RetFindSources( p );
        if ( 2*Vec_IntSize(&p->vEdgeLinks) > Vec_IntCap(&p->vEdgeLinks) )
            Vec_IntGrow( &p->vEdgeLinks, 4*Vec_IntSize(&p->vEdgeLinks) );
    }
    ABC_SWAP( Vec_Int_t, *vMoves, p->vMoves );
    Wln_RetFree( p );
    if ( fVerbose )
    {
        printf( "\nThe resulting moves recorded in terms of name IDs of the NDR nodes:\n" );
        Vec_IntPrint( vMoves );
    }
    else
    {
        printf( "Retiming instruction contains %d moves and %d total retimed objects.\n", nMoves, Vec_IntSize(vMoves)-2*nMoves-2 );
        printf( "Initial delay = %d.  The best delay achieved = %d.  Improvement = %d. (%6.2f %%)\n", 
            DelayInit, DelayBest, DelayInit - DelayBest, 100.0 * (DelayInit - DelayBest) / DelayInit );
    }
    return vMoves;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkRetimeCreateDelayInfo()

void Wln_NtkRetimeCreateDelayInfo

(

Wln_Ntk_t *

pNtk

)

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

Synopsis [Retiming computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 592 of file wlnRetime.c.

{
    int i, iObj;
//    if ( Wln_NtkHasInstId(pNtk) )
//        Vec_IntErase( &pNtk->vInstIds );
    if ( Wln_NtkHasInstId(pNtk) )
    {
        printf( "Using delays given by the user in the input file.\n" );
        Wln_NtkForEachObj( pNtk, iObj )
            if ( !Wln_ObjIsCio(pNtk, iObj) && !Wln_ObjIsConst(pNtk, iObj) && Wln_ObjInstId(pNtk, iObj) == 0 )
                printf( "Warning: Object %d of type %s has zero delay. Retiming will not work correctly.\n", iObj, Abc_OperName(Wln_ObjType(pNtk, iObj)) );
    }
    else
    {
        printf( "The design has no delay information.\n" );
        Wln_NtkCleanInstId(pNtk);
        Wln_NtkForEachObj( pNtk, iObj )
        {
            if ( Wln_ObjIsFf(pNtk, iObj) || Wln_ObjType(pNtk, iObj) == ABC_OPER_SLICE || Wln_ObjType(pNtk, iObj) == ABC_OPER_CONCAT )
                Wln_ObjSetInstId( pNtk, iObj, 1 );
            else if ( !Wln_ObjIsCio(pNtk, iObj) && Wln_ObjFaninNum(pNtk, iObj) > 0 )
                Wln_ObjSetInstId( pNtk, iObj, 10 );
        }
        Wln_NtkForEachCo( pNtk, iObj, i ) 
        {
            if ( Wln_ObjType(pNtk, Wln_ObjFanin0(pNtk, iObj)) != ABC_OPER_LUT )
                Wln_ObjSetInstId( pNtk, Wln_ObjFanin0(pNtk, iObj), 1 );
        }
        printf( "Assuming default delays: 10 units for most nodes and 1 unit for bit-slice, concat, and buffers driving COs.\n" );
    }
}

Here is the caller graph for this function:

Wln_RetAddToMoves()

void Wln_RetAddToMoves	(	Wln_Ret_t *	p,
		Vec_Int_t *	vSet,
		int	Delay,
		int	fForward,
		int	nMoves,
		int	fSkipSimple,
		int	fVerbose )

Definition at line 555 of file wlnRetime.c.

{
    int i, iObj;
    if ( vSet == NULL )
    {
        printf( "Move %4d : Recording initial state     (delay = %6d)\n", nMoves, Delay );
        Vec_IntPushTwo( &p->vMoves, Delay, 0 );
        return;
    }
    printf( "Move %4d : Recording %s retiming (delay = %6d) :", nMoves, fForward ? "forward " : "backward", Delay );
    Vec_IntPush( &p->vMoves, Delay );
    Vec_IntForEachEntry( vSet, iObj, i )
    {
        int NameId = Vec_IntEntry( &p->pNtk->vNameIds, iObj );
        if ( fSkipSimple && (Wln_ObjIsFf(p->pNtk, iObj) || Wln_ObjType(p->pNtk, iObj) == ABC_OPER_SLICE || Wln_ObjType(p->pNtk, iObj) == ABC_OPER_CONCAT) )
            continue;
        Vec_IntPush( &p->vMoves, fForward ? -NameId : NameId );
        if ( fVerbose )
            printf( " %d (NameID = %d)  ", fForward ? -iObj : iObj, fForward ? -NameId : NameId );
    }
    Vec_IntPush( &p->vMoves, 0 );
    if ( !fVerbose )
        printf( " %3d retimed objects", Vec_IntSize(vSet) );
    printf( "\n" );
}

Here is the caller graph for this function:

Wln_RetAlloc()

Wln_Ret_t * Wln_RetAlloc

(

Wln_Ntk_t *

pNtk

)

Definition at line 149 of file wlnRetime.c.

{
    Wln_Ret_t * p; int k, iObj, iFanin, fFirst = 1;
    Vec_Int_t * vRefsCopy = Vec_IntAlloc(0);
    p = ABC_CALLOC( Wln_Ret_t, 1 );
    p->pNtk = pNtk;
    Wln_NtkCreateRefs( pNtk );
    // print objects without fanout
    Wln_NtkForEachObj( pNtk, iObj )
        if ( Wln_ObjRefs(pNtk, iObj) == 0 && !Wln_ObjIsCio(pNtk, iObj) )
        {
            if ( fFirst )
            {
                fFirst = 0;
                printf( "Objects without fanout:\n" );
            }
            Wln_ObjPrint(pNtk, iObj);
        }
    // start fanin/fanout maps
    Wln_NtkStartFaninMap( pNtk, &p->vFanins, 2 );
    Wln_NtkStartFanoutMap( pNtk, &p->vFanouts, &pNtk->vRefs, 2 );
    ABC_SWAP( Vec_Int_t, *vRefsCopy, pNtk->vRefs );
    Wln_NtkCleanRefs( pNtk );
    Vec_IntGrow( &p->vEdgeLinks, 10*Wln_NtkFfNum(pNtk) );
    Vec_IntPushTwo( &p->vEdgeLinks, -1, -1 );
    Wln_NtkForEachObj( pNtk, iObj )
        Wln_ObjForEachFanin( pNtk, iObj, iFanin, k )
        {
            int * pFanins  = Wln_RetFanins( p, iObj );
            int * pFanouts = Wln_RetFanouts( p, iFanin );
            int Index      = Wln_ObjRefsInc( pNtk, iFanin );
            pFanins[2*k+0]      = iFanin;
            pFanins[2*k+1]      = Wln_ObjIsFf(pNtk, iFanin) ? Vec_IntSize(&p->vEdgeLinks) : 0;
            pFanouts[2*Index+0] = iObj;
            pFanouts[2*Index+1] = Vec_IntEntry(&p->vFanins, iObj) + 2*k + 1;
            if ( Wln_ObjIsFf(pNtk, iFanin) )
                Vec_IntPushTwo( &p->vEdgeLinks, 0, iFanin );
        }
    // double-check the current number of fanouts added
    Wln_NtkForEachObj( pNtk, iObj )
        assert( Wln_ObjRefs(pNtk, iObj) == Vec_IntEntry(vRefsCopy, iObj) );
    Vec_IntFree( vRefsCopy );
    // other data
    p->nClasses = Wln_RetComputeFfClasses( pNtk, &p->vFfClasses );
    //ABC_SWAP( Vec_Int_t, p->vNodeDelays, pNtk->vInstIds );
    Vec_IntAppend( &p->vNodeDelays, &pNtk->vInstIds );
    Vec_IntGrow( &p->vSources, 1000 );
    Vec_IntGrow( &p->vSinks, 1000 );
    Vec_IntGrow( &p->vFront, 1000 );
    Vec_IntGrow( &p->vMoves, 1000 );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetCheckBackward()

int Wln_RetCheckBackward	(	Wln_Ret_t *	p,
		Vec_Int_t *	vSet )

Definition at line 452 of file wlnRetime.c.

{
    int i, iObj;
    Vec_IntForEachEntry( vSet, iObj, i )
        if ( !Wln_RetCheckBackwardOne( p, iObj ) )
            return 0;
    return 1;
}

Here is the caller graph for this function:

Wln_RetCheckForward()

int Wln_RetCheckForward	(	Wln_Ret_t *	p,
		Vec_Int_t *	vSet )

Definition at line 424 of file wlnRetime.c.

{
    int i, iObj;
    Vec_IntForEachEntry( vSet, iObj, i )
        if ( !Wln_RetCheckForwardOne( p, iObj ) )
            return 0;
    return 1;
}

Here is the caller graph for this function:

Wln_RetComputeFfClasses()

int Wln_RetComputeFfClasses	(	Wln_Ntk_t *	pNtk,
		Vec_Int_t *	vClasses )

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

Synopsis [Retiming manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 130 of file wlnRetime.c.

{
    int i, k, iObj, nClasses;
    Hsh_VecMan_t * p = Hsh_VecManStart( 10 );
    Vec_Int_t * vFlop = Vec_IntAlloc( 6 ); 
    Vec_IntFill( vClasses, Wln_NtkObjNum(pNtk), -1 );
    Wln_NtkForEachFf( pNtk, iObj, i )
    {
        Vec_IntClear( vFlop );
        for ( k = 1; k <= 6; k++ )
            Vec_IntPush( vFlop, Wln_ObjFanin(pNtk, iObj, k) );
        Vec_IntWriteEntry( vClasses, iObj, Hsh_VecManAdd(p, vFlop) );
    }
    nClasses = Hsh_VecSize( p );
    Hsh_VecManStop( p );
    Vec_IntFree( vFlop );
    printf( "Detected %d flops and %d flop classes.\n", Wln_NtkFfNum(pNtk), nClasses );
    return nClasses;
}

Here is the caller graph for this function:

Wln_RetFindSources()

void Wln_RetFindSources

(

Wln_Ret_t *

p

)

Definition at line 324 of file wlnRetime.c.

{
    int i, iObj;
    Vec_IntClear( &p->vSources );
    Wln_NtkIncrementTravId( p->pNtk );
    Vec_IntForEachEntry( &p->vSinks, iObj, i )
        Wln_RetFindSources_rec( p, iObj );
 
//    printf( "Sources: " );
//    Vec_IntPrint( &p->vSources );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetFindSources_rec()

void Wln_RetFindSources_rec	(	Wln_Ret_t *	p,
		int	iObj )

Definition at line 312 of file wlnRetime.c.

{
    int k, iFanin, * pLink, FaninDelay;
    if ( Wln_ObjIsCi(p->pNtk, iObj) || Wln_ObjCheckTravId(p->pNtk, iObj) )
        return;
    FaninDelay = Vec_IntEntry( &p->vPathDelays, iObj ) - Vec_IntEntry( &p->vNodeDelays, iObj );
    Wln_RetForEachFanin( p, iObj, iFanin, pLink, k )
        if ( !pLink[0] && Vec_IntEntry(&p->vPathDelays, iFanin) == FaninDelay )
            Wln_RetFindSources_rec( p, iFanin );
    if ( FaninDelay == 0 )
        Vec_IntPush( &p->vSources, iObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetFree()

void Wln_RetFree

(

Wln_Ret_t *

p

)

Definition at line 201 of file wlnRetime.c.

{
    ABC_FREE( p->vFanins.pArray );
    ABC_FREE( p->vFanouts.pArray );
    ABC_FREE( p->vEdgeLinks.pArray );
    ABC_FREE( p->vFfClasses.pArray );
    ABC_FREE( p->vNodeDelays.pArray );
    ABC_FREE( p->vPathDelays.pArray );
    ABC_FREE( p->vSources.pArray );
    ABC_FREE( p->vSinks.pArray );
    ABC_FREE( p->vFront.pArray );
    ABC_FREE( p->vMoves.pArray );
    ABC_FREE( p );
}

Here is the caller graph for this function:

Wln_RetHeadToTail()

int * Wln_RetHeadToTail	(	Wln_Ret_t *	p,
		int *	pHead )

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

Synopsis [Retimability check.]

Description []

SideEffects []

SeeAlso []

Definition at line 396 of file wlnRetime.c.

{
    int * pLink;
    assert( pHead[0] );
    pLink = Vec_IntEntryP( &p->vEdgeLinks, pHead[0] );
    if ( pLink[0] == 0 )
        return pHead;
    return Wln_RetHeadToTail( p, pLink );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetInsertOneFanin()

void Wln_RetInsertOneFanin	(	Wln_Ret_t *	p,
		int	iObj,
		int	iFlop )

Definition at line 506 of file wlnRetime.c.

{
    int k, iHead, iFanin, * pLink;
    int * pFanins  = Wln_RetFanins( p, iObj );
    assert( Wln_ObjIsFf( p->pNtk, iFlop ) );
    Wln_RetForEachFanin( p, iObj, iFanin, pLink, k )
    {
        if ( Wln_ObjIsFf(p->pNtk, iObj) && k > 0 )
            continue;
        iHead = pFanins[2*k+1];
        pFanins[2*k+1] = Vec_IntSize(&p->vEdgeLinks);
        Vec_IntPushTwo( &p->vEdgeLinks, iHead, iFlop );
    }
}

Here is the caller graph for this function:

Wln_RetInsertOneFanout()

void Wln_RetInsertOneFanout	(	Wln_Ret_t *	p,
		int	iObj,
		int	iFlop )

Definition at line 520 of file wlnRetime.c.

{
    int k, iFanin, * pLink;
    assert( Wln_ObjIsFf( p->pNtk, iFlop ) );
    Wln_RetForEachFanout( p, iObj, iFanin, pLink, k )
    {
        if ( pLink[0] )
            pLink = Wln_RetHeadToTail( p, pLink );
        //assert( pLink[0] == 0 );
        pLink[0] = Vec_IntSize(&p->vEdgeLinks);
        Vec_IntPushTwo( &p->vEdgeLinks, 0, iFlop );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetMarkChanges()

void Wln_RetMarkChanges	(	Wln_Ret_t *	p,
		Vec_Int_t *	vFront )

Definition at line 252 of file wlnRetime.c.

{
    int i, iObj;
    if ( vFront )
    {
        Vec_IntForEachEntry( vFront, iObj, i )
            Wln_RetMarkChanges_rec( p, iObj );
    }
    else
    {
        Vec_IntFill( &p->vPathDelays, Wln_NtkObjNum(p->pNtk), -1 );
        Wln_NtkForEachCi( p->pNtk, iObj, i )
            Vec_IntWriteEntry( &p->vPathDelays, iObj, 0 );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetMarkChanges_rec()

void Wln_RetMarkChanges_rec	(	Wln_Ret_t *	p,
		int	iObj )

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

Synopsis [Delay propagation.]

Description []

SideEffects []

SeeAlso []

Definition at line 242 of file wlnRetime.c.

{
    int k, iFanout, * pLink, * pDelay = Vec_IntEntryP( &p->vPathDelays, iObj );
    if ( *pDelay < 0 )
        return;
    *pDelay = -1;
    Wln_RetForEachFanout( p, iObj, iFanout, pLink, k )
        if ( !pLink[0] )
            Wln_RetMarkChanges_rec( p, iFanout );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetMarkPaths()

void Wln_RetMarkPaths	(	Wln_Ntk_t *	p,
		int	fVerbose )

Definition at line 374 of file wlnRetime.c.

{
    int i, iObj;
    Wln_NtkIncrementTravId( p );
    Wln_NtkIncrementTravId( p );
    Wln_NtkForEachPi( p, iObj, i )
        Wln_ObjSetTravIdPrevious( p, iObj );
    Wln_NtkForEachPo( p, iObj, i )
        Wln_RetMarkPaths_rec( p, Wln_ObjFanin0(p, iObj), fVerbose );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetMarkPaths_rec()

int Wln_RetMarkPaths_rec	(	Wln_Ntk_t *	p,
		int	iObj,
		int	fVerbose )

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

Synopsis [Mark paths from PIs to POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 347 of file wlnRetime.c.

{
    int k, iFanin, fPrev = 1;
    if ( Wln_ObjIsTravIdPrevious(p, iObj) )
        return 1;
    if ( Wln_ObjIsTravIdCurrent(p, iObj) )
        return 0;
    if ( Wln_ObjIsCio(p, iObj) || Wln_ObjIsFf(p, iObj) )
        return 0;
    Wln_ObjForEachFanin( p, iObj, iFanin, k )
        fPrev &= Wln_RetMarkPaths_rec( p, iFanin, fVerbose );
    if ( fPrev )
    {
        Wln_ObjSetTravIdPrevious( p, iObj );
        if ( Vec_IntEntry(&p->vInstIds, iObj) > 0 )
        {
            if ( fVerbose )
                printf( "Updating delay %5d -> %5d : ", Vec_IntEntry(&p->vInstIds, iObj), 1 );
            if ( fVerbose )
                Wln_ObjPrint( p, iObj );
            Vec_IntWriteEntry( &p->vInstIds, iObj, 1 );
        }
        return 1;
    }
    Wln_ObjSetTravIdCurrent( p, iObj );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetMemUsage()

int Wln_RetMemUsage

(

Wln_Ret_t *

p

)

Definition at line 215 of file wlnRetime.c.

{
    int Mem = sizeof(Wln_Ret_t);
    Mem += 4 * p->vFanins.nCap;
    Mem += 4 * p->vFanouts.nCap;
    Mem += 4 * p->vEdgeLinks.nCap;
    Mem += 4 * p->vFfClasses.nCap;
    Mem += 4 * p->vNodeDelays.nCap;
    Mem += 4 * p->vPathDelays.nCap;
    Mem += 4 * p->vSources.nCap;
    Mem += 4 * p->vSinks.nCap;
    Mem += 4 * p->vFront.nCap;
    Mem += 4 * p->vMoves.nCap;
    return Mem;
}

Wln_RetPrint()

void Wln_RetPrint	(	Wln_Ret_t *	p,
		int	fVerbose )

Definition at line 92 of file wlnRetime.c.

{
    int iObj, nCount = 0;
    Wln_NtkForEachObj( p->pNtk, iObj )
        if ( Wln_ObjInstId(p->pNtk, iObj) > 1 )
            nCount++;
    printf( "Total number of objects = %d.  Objects with non-trivial delay = %d.\n", Wln_NtkObjNum(p->pNtk), nCount );
    if ( !fVerbose )
    {
        int nPrints = 0, nLimit = 5;
        printf( "The following %d objects have non-trivial delays:\n", nLimit );
        Wln_NtkForEachObj( p->pNtk, iObj )
        {
            if ( Wln_ObjInstId(p->pNtk, iObj) <= 1 )
                continue;
            Wln_RetPrintObj( p, iObj );
            if ( ++nPrints == nLimit )
                break;
        }
        return;
    }
    printf( "Printing %d objects of network \"%s\":\n", Wln_NtkObjNum(p->pNtk), p->pNtk->pName );
    Wln_NtkForEachObj( p->pNtk, iObj )
        Wln_RetPrintObj( p, iObj );
    printf( "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetPrintObj()

void Wln_RetPrintObj	(	Wln_Ret_t *	p,
		int	iObj )

FUNCTION DEFINITIONS ///.

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

Synopsis [Printing procedure.]

Description []

SideEffects []

SeeAlso []

Definition at line 76 of file wlnRetime.c.

{
    int k, iFanin, Type = Wln_ObjType(p->pNtk, iObj), * pLink;
    printf( "Obj %6d : Type = %6s  NameId = %5d  InstId = %5d  Fanins = %d : ", 
        iObj, Abc_OperName(Type), Wln_ObjNameId(p->pNtk, iObj), Wln_ObjInstId(p->pNtk, iObj), Wln_ObjFaninNum(p->pNtk, iObj) );
    Wln_RetForEachFanin( p, iObj, iFanin, pLink, k )
    {
        printf( "%5d ", iFanin );
        if ( !pLink[0] )
            continue;
        printf( "(%d : %d %d) ", pLink[0], 
            Vec_IntEntry(&p->vEdgeLinks, pLink[0]), 
            Vec_IntEntry(&p->vEdgeLinks, pLink[0]+1) );
    }
    printf( "\n" );
}

Here is the caller graph for this function:

Wln_RetPropDelay()

int Wln_RetPropDelay

(

Wln_Ret_t *

p

)

Definition at line 285 of file wlnRetime.c.

{
    int iObj, DelayMax = 0;
    Vec_IntClear( &p->vSinks );
    Wln_NtkForEachObj( p->pNtk, iObj )
        if ( !Wln_ObjIsCio(p->pNtk, iObj) )
        {
            int Delay = Wln_RetPropDelay_rec(p, iObj);
            if ( DelayMax == Delay )
                Vec_IntPush( &p->vSinks, iObj );
            else if ( DelayMax < Delay )
            {
                DelayMax = Delay;
                Vec_IntFill( &p->vSinks, 1, iObj );
            }
        }
 
//    Vec_IntForEachEntry( &p->vPathDelays, iObj, i )
//        printf( "Obj = %d.  Delay = %d.\n", i, iObj );
//    printf( "\n" );
 
//    printf( "Sinks: " );
//    Vec_IntPrint( &p->vSinks );
 
    return DelayMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetPropDelay_rec()

int Wln_RetPropDelay_rec	(	Wln_Ret_t *	p,
		int	iObj )

Definition at line 267 of file wlnRetime.c.

{
    int k, iFanin, * pLink, * pDelay = Vec_IntEntryP( &p->vPathDelays, iObj );
    if ( *pDelay >= 0 )
        return *pDelay;
    *pDelay = 0;
    Wln_RetForEachFanin( p, iObj, iFanin, pLink, k )
    {
        if ( Wln_ObjIsFf(p->pNtk, iObj) && k > 0 )
            continue;
        if ( pLink[0] )
            *pDelay = Abc_MaxInt(*pDelay, 0);
        else
            *pDelay = Abc_MaxInt(*pDelay, Wln_RetPropDelay_rec(p, iFanin));
    }
    *pDelay += Vec_IntEntry( &p->vNodeDelays, iObj );
    return *pDelay;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetRemoveOneFanin()

int Wln_RetRemoveOneFanin	(	Wln_Ret_t *	p,
		int	iObj )

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

Synopsis [Moving flops.]

Description []

SideEffects []

SeeAlso []

Definition at line 473 of file wlnRetime.c.

{
    int k, iFanin, * pLink, iFlop, iFlop1 = -1;
    int * pFanins  = Wln_RetFanins( p, iObj );
    Wln_RetForEachFanin( p, iObj, iFanin, pLink, k )
    {
        if ( Wln_ObjIsFf(p->pNtk, iObj) && k > 0 )
            continue;
        assert( pLink[0] );
        iFlop = Vec_IntEntry( &p->vEdgeLinks, pLink[0] + 1 );
        pFanins[2*k+1] = Vec_IntEntry( &p->vEdgeLinks, pLink[0] );
        assert( Wln_ObjIsFf( p->pNtk, iFlop ) );
        if ( iFlop1 == -1 )
            iFlop1 = iFlop;
    }
    return iFlop1;
}

Here is the caller graph for this function:

Wln_RetRemoveOneFanout()

int Wln_RetRemoveOneFanout	(	Wln_Ret_t *	p,
		int	iObj )

Definition at line 490 of file wlnRetime.c.

{
    int k, iFanin, * pLink, iFlop, iFlop1 = -1;
    //int * pFanins  = Wln_RetFanins( p, iObj );
    Wln_RetForEachFanout( p, iObj, iFanin, pLink, k )
    {
        assert( pLink[0] );
        pLink = Wln_RetHeadToTail( p, pLink );
        iFlop = Vec_IntEntry( &p->vEdgeLinks, pLink[0] + 1 );
        pLink[0] = 0;
        assert( Wln_ObjIsFf( p->pNtk, iFlop ) );
        if ( iFlop1 == -1 )
            iFlop1 = iFlop;
    }
    return iFlop1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetRetimeBackward()

void Wln_RetRetimeBackward	(	Wln_Ret_t *	p,
		Vec_Int_t *	vSet )

Definition at line 544 of file wlnRetime.c.

{
    int i, iObj, iFlop;
    Vec_IntForEachEntry( vSet, iObj, i )
    {
        iFlop = Wln_RetRemoveOneFanout( p, iObj );
        if ( iFlop == -1 )
            continue;
        Wln_RetInsertOneFanin( p, iObj, iFlop );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_RetRetimeForward()

void Wln_RetRetimeForward	(	Wln_Ret_t *	p,
		Vec_Int_t *	vSet )

Definition at line 533 of file wlnRetime.c.

{
    int i, iObj, iFlop;
    Vec_IntForEachEntry( vSet, iObj, i )
    {
        iFlop = Wln_RetRemoveOneFanin( p, iObj );
        if ( iFlop == -1 )
            continue;
        Wln_RetInsertOneFanout( p, iObj, iFlop );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: