tim.h File Reference

Go to the source code of this file.

Macros
#define	TIM_ETERNITY   1000000000
	MACRO DEFINITIONS ///. More...

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Tim_Man_t_	Tim_Man_t
	INCLUDES ///. More...

Functions
void	Tim_ManCreateBox (Tim_Man_t *p, int firstIn, int nIns, int firstOut, int nOuts, int iDelayTable)
	ITERATORS ///. More...
int	Tim_ManBoxForCi (Tim_Man_t *p, int iCo)
int	Tim_ManBoxForCo (Tim_Man_t *p, int iCi)
int	Tim_ManBoxInputFirst (Tim_Man_t *p, int iBox)
int	Tim_ManBoxInputLast (Tim_Man_t *p, int iBox)
int	Tim_ManBoxOutputFirst (Tim_Man_t *p, int iBox)
int	Tim_ManBoxOutputLast (Tim_Man_t *p, int iBox)
int	Tim_ManBoxInputNum (Tim_Man_t *p, int iBox)
int	Tim_ManBoxOutputNum (Tim_Man_t *p, int iBox)
int	Tim_ManBoxDelayTableId (Tim_Man_t *p, int iBox)
float *	Tim_ManBoxDelayTable (Tim_Man_t *p, int iBox)
int	Tim_ManBoxIsBlack (Tim_Man_t *p, int iBox)
int	Tim_ManBoxCopy (Tim_Man_t *p, int iBox)
void	Tim_ManBoxSetCopy (Tim_Man_t *p, int iBox, int iCopy)
int	Tim_ManBoxFindFromCiNum (Tim_Man_t *p, int iCiNum)
Vec_Str_t *	Tim_ManSave (Tim_Man_t *p, int fHieOnly)
	FUNCTION DEFINITIONS ///. More...
Tim_Man_t *	Tim_ManLoad (Vec_Str_t *p, int fHieOnly)
Tim_Man_t *	Tim_ManStart (int nCis, int nCos)
	DECLARATIONS ///. More...
Tim_Man_t *	Tim_ManDup (Tim_Man_t *p, int fUnitDelay)
Tim_Man_t *	Tim_ManTrim (Tim_Man_t *p, Vec_Int_t *vBoxPres)
Tim_Man_t *	Tim_ManReduce (Tim_Man_t *p, Vec_Int_t *vBoxesLeft, int nTermsDiff)
Vec_Int_t *	Tim_ManAlignTwo (Tim_Man_t *pSpec, Tim_Man_t *pImpl)
void	Tim_ManCreate (Tim_Man_t *p, void *pLib, Vec_Flt_t *vInArrs, Vec_Flt_t *vOutReqs)
float *	Tim_ManGetArrTimes (Tim_Man_t *p)
float *	Tim_ManGetReqTimes (Tim_Man_t *p)
void	Tim_ManStop (Tim_Man_t *p)
void	Tim_ManStopP (Tim_Man_t **p)
void	Tim_ManPrint (Tim_Man_t *p)
void	Tim_ManPrintStats (Tim_Man_t *p, int nAnd2Delay)
int	Tim_ManCiNum (Tim_Man_t *p)
int	Tim_ManCoNum (Tim_Man_t *p)
int	Tim_ManPiNum (Tim_Man_t *p)
int	Tim_ManPoNum (Tim_Man_t *p)
int	Tim_ManBoxNum (Tim_Man_t *p)
int	Tim_ManBlackBoxNum (Tim_Man_t *p)
int	Tim_ManDelayTableNum (Tim_Man_t *p)
void	Tim_ManSetDelayTables (Tim_Man_t *p, Vec_Ptr_t *vDelayTables)
void	Tim_ManTravIdDisable (Tim_Man_t *p)
void	Tim_ManTravIdEnable (Tim_Man_t *p)
void	Tim_ManInitPiArrival (Tim_Man_t *p, int iPi, float Delay)
	DECLARATIONS ///. More...
void	Tim_ManInitPoRequired (Tim_Man_t *p, int iPo, float Delay)
void	Tim_ManInitPiArrivalAll (Tim_Man_t *p, float Delay)
void	Tim_ManInitPoRequiredAll (Tim_Man_t *p, float Delay)
void	Tim_ManSetCoArrival (Tim_Man_t *p, int iCo, float Delay)
void	Tim_ManSetCiRequired (Tim_Man_t *p, int iCi, float Delay)
void	Tim_ManSetCoRequired (Tim_Man_t *p, int iCo, float Delay)
float	Tim_ManGetCiArrival (Tim_Man_t *p, int iCi)
float	Tim_ManGetCoRequired (Tim_Man_t *p, int iCo)
void	Tim_ManIncrementTravId (Tim_Man_t *p)
	DECLARATIONS ///. More...
void	Tim_ManSetCurrentTravIdBoxInputs (Tim_Man_t *p, int iBox)
void	Tim_ManSetCurrentTravIdBoxOutputs (Tim_Man_t *p, int iBox)
void	Tim_ManSetPreviousTravIdBoxInputs (Tim_Man_t *p, int iBox)
void	Tim_ManSetPreviousTravIdBoxOutputs (Tim_Man_t *p, int iBox)
int	Tim_ManIsCiTravIdCurrent (Tim_Man_t *p, int iCi)
int	Tim_ManIsCoTravIdCurrent (Tim_Man_t *p, int iCo)

Macro Definition Documentation

#define TIM_ETERNITY   1000000000

MACRO DEFINITIONS ///.

Definition at line 98 of file tim.h.

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct Tim_Man_t_ Tim_Man_t

INCLUDES ///.

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

FileName [tim.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchy/timing manager.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - April 28, 2007.]

Revision [

Id:

tim.h,v 1.00 2007/04/28 00:00:00 alanmi Exp

]PARAMETERS ///BASIC TYPES ///

Definition at line 92 of file tim.h.

Function Documentation

Vec_Int_t* Tim_ManAlignTwo	(	Tim_Man_t *	pSpec,
		Tim_Man_t *	pImpl
	)

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

Synopsis [Aligns two sets of boxes using the copy field.]

Description []

SideEffects []

SeeAlso []

Definition at line 344 of file timMan.c.

{
    Vec_Int_t * vBoxPres;
    Tim_Box_t * pBox;
    int i;
    assert( Tim_ManBoxNum(pSpec) > Tim_ManBoxNum(pImpl) );
    // check if boxes of pImpl can be aligned
    Tim_ManForEachBox( pImpl, pBox, i )
        if ( pBox->iCopy < 0 || pBox->iCopy >= Tim_ManBoxNum(pSpec) ) 
            return NULL;
    // map dropped boxes into 1, others into 0
    vBoxPres = Vec_IntStart( Tim_ManBoxNum(pSpec) );
    Tim_ManForEachBox( pImpl, pBox, i )
    {
        assert( !Vec_IntEntry(vBoxPres, pBox->iCopy) );
        Vec_IntWriteEntry( vBoxPres, pBox->iCopy, 1 );
    }
    return vBoxPres;
}

int Tim_ManBlackBoxNum

(

Tim_Man_t *

p

)

Definition at line 706 of file timMan.c.

{
    Tim_Box_t * pBox;
    int i, Counter = 0;
    if ( Tim_ManBoxNum(p) )
        Tim_ManForEachBox( p, pBox, i )
            Counter += pBox->fBlack;
    return Counter;
}

int Tim_ManBoxCopy	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the copy of the box.]

Description []

SideEffects []

SeeAlso []

Definition at line 274 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->iCopy;
}

float* Tim_ManBoxDelayTable	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Return the delay table.]

Description []

SideEffects []

SeeAlso []

Definition at line 234 of file timBox.c.

{
    float * pTable;
    Tim_Box_t * pBox = Tim_ManBox(p, iBox);
    if ( pBox->iDelayTable < 0 )
        return NULL;
    pTable = (float *)Vec_PtrEntry( p->vDelayTables, pBox->iDelayTable );
    assert( (int)pTable[1] == pBox->nInputs );
    assert( (int)pTable[2] == pBox->nOutputs );
    return pTable;
}

int Tim_ManBoxDelayTableId	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Return the delay table id.]

Description []

SideEffects []

SeeAlso []

Definition at line 218 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->iDelayTable;
}

int Tim_ManBoxFindFromCiNum	(	Tim_Man_t *	p,
		int	iCiNum
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 306 of file timBox.c.

{
    Tim_Box_t * pBox;
    int i;
    assert( iCiNum >= 0 && iCiNum < Tim_ManCiNum(p) );
    if ( iCiNum < Tim_ManPiNum(p) )
        return -1;
    Tim_ManForEachBox( p, pBox, i )
        if ( iCiNum < Tim_ManBoxOutputFirst(p, i) )
            return i - 1;
    return -2;
}

int Tim_ManBoxForCi	(	Tim_Man_t *	p,
		int	iCi
	)

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

Synopsis [Returns the box number for the given input.]

Description []

SideEffects []

SeeAlso []

Definition at line 86 of file timBox.c.

{
    if ( iCi >= p->nCis )
        return -1;
    return p->pCis[iCi].iObj2Box;
}

int Tim_ManBoxForCo	(	Tim_Man_t *	p,
		int	iCo
	)

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

Synopsis [Returns the box number for the given output.]

Description []

SideEffects []

SeeAlso []

Definition at line 104 of file timBox.c.

{
    if ( iCo >= p->nCos )
        return -1;
    return p->pCos[iCo].iObj2Box;
}

int Tim_ManBoxInputFirst	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the first input of the box.]

Description []

SideEffects []

SeeAlso []

Definition at line 122 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->Inouts[0];
}

int Tim_ManBoxInputLast	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the last input of the box.]

Description []

SideEffects []

SeeAlso []

Definition at line 138 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->Inouts[0] + Tim_ManBoxInputNum(p, iBox) - 1;
}

int Tim_ManBoxInputNum	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the number of box inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 186 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->nInputs;
}

int Tim_ManBoxIsBlack	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Return 1 if the box is black.]

Description []

SideEffects []

SeeAlso []

Definition at line 257 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->fBlack;
}

int Tim_ManBoxNum

(

Tim_Man_t *

p

)

Definition at line 702 of file timMan.c.

{
    return p->vBoxes ? Vec_PtrSize(p->vBoxes) : 0;
}

int Tim_ManBoxOutputFirst	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the first output of the box.]

Description []

SideEffects []

SeeAlso []

Definition at line 154 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->Inouts[Tim_ManBox(p, iBox)->nInputs];
}

int Tim_ManBoxOutputLast	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the last output of the box.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->Inouts[Tim_ManBox(p, iBox)->nInputs] + Tim_ManBoxOutputNum(p, iBox) - 1;
}

int Tim_ManBoxOutputNum	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Returns the number of box outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file timBox.c.

{
    return Tim_ManBox(p, iBox)->nOutputs;
}

void Tim_ManBoxSetCopy	(	Tim_Man_t *	p,
		int	iBox,
		int	iCopy
	)

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

Synopsis [Sets the copy of the box.]

Description []

SideEffects []

SeeAlso []

Definition at line 290 of file timBox.c.

{
    Tim_ManBox(p, iBox)->iCopy = iCopy;
}

int Tim_ManCiNum

(

Tim_Man_t *

p

)

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

Synopsis [Read parameters.]

Description []

SideEffects []

SeeAlso []

Definition at line 680 of file timMan.c.

{
    return p->nCis;
}

int Tim_ManCoNum

(

Tim_Man_t *

p

)

Definition at line 684 of file timMan.c.

{
    return p->nCos;
}

void Tim_ManCreate	(	Tim_Man_t *	p,
		void *	pLib,
		Vec_Flt_t *	vInArrs,
		Vec_Flt_t *	vOutReqs
	)

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

Synopsis [Creates manager using hierarchy / box library / delay info.]

Description []

SideEffects []

SeeAlso []

Definition at line 403 of file timMan.c.

{
    If_LibBox_t * pLibBox = (If_LibBox_t *)pLib;
    If_Box_t * pIfBox;
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    float * pTable;
    int i, k;
    assert( p->vDelayTables == NULL );
    p->vDelayTables = pLibBox ? Vec_PtrStart( Vec_PtrSize(pLibBox->vBoxes) ) : Vec_PtrAlloc( 100 );
    if ( p->vBoxes )
    Tim_ManForEachBox( p, pBox, i )
    {
        if ( pBox->iDelayTable == -1 || pLibBox == NULL )
        {
            // create table with constants
            pTable = ABC_ALLOC( float, 3 + pBox->nInputs * pBox->nOutputs );
            pTable[0] = pBox->iDelayTable;
            pTable[1] = pBox->nInputs;
            pTable[2] = pBox->nOutputs;
            for ( k = 0; k < pBox->nInputs * pBox->nOutputs; k++ )
                pTable[3 + k] = 1.0;
            // save table
            pBox->iDelayTable = Vec_PtrSize(p->vDelayTables);
            Vec_PtrPush( p->vDelayTables, pTable );
            continue;
        }
        assert( pBox->iDelayTable >= 0 && pBox->iDelayTable < Vec_PtrSize(pLibBox->vBoxes) );
        pIfBox = (If_Box_t *)Vec_PtrEntry( pLibBox->vBoxes, pBox->iDelayTable );
        assert( pIfBox != NULL );
        assert( pIfBox->nPis == pBox->nInputs );
        assert( pIfBox->nPos == pBox->nOutputs );
        pBox->fBlack = pIfBox->fBlack;
        if ( Vec_PtrEntry( p->vDelayTables, pBox->iDelayTable ) != NULL )
            continue;
        // create table of boxes
        pTable = ABC_ALLOC( float, 3 + pBox->nInputs * pBox->nOutputs );
        pTable[0] = pBox->iDelayTable;
        pTable[1] = pBox->nInputs;
        pTable[2] = pBox->nOutputs;
        for ( k = 0; k < pBox->nInputs * pBox->nOutputs; k++ )
            pTable[3 + k] = pIfBox->pDelays[k];
        // save table
        Vec_PtrWriteEntry( p->vDelayTables, pBox->iDelayTable, pTable );
    }
    // create arrival times
    if ( vInArrs )
    {
        assert( Vec_FltSize(vInArrs) == Tim_ManPiNum(p) );
        Tim_ManForEachPi( p, pObj, i )
            pObj->timeArr = Vec_FltEntry(vInArrs, i);

    }
    // create required times
    if ( vOutReqs )
    {
        k = 0;
        assert( Vec_FltSize(vOutReqs) == Tim_ManPoNum(p) );
        Tim_ManForEachPo( p, pObj, i )
            pObj->timeReq = Vec_FltEntry(vOutReqs, k++);
        assert( k == Tim_ManPoNum(p) );
    }
}

void Tim_ManCreateBox	(	Tim_Man_t *	p,
		int	firstIn,
		int	nIns,
		int	firstOut,
		int	nOuts,
		int	iDelayTable
	)

ITERATORS ///.

SEQUENTIAL ITERATORS ///FUNCTION DECLARATIONS ///

ITERATORS ///.

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

FileName [timBox.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchy/timing manager.]

Synopsis [Manipulation of timing boxes.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - April 28, 2007.]

Revision [

Id:

timBox.c,v 1.00 2007/04/28 00:00:00 alanmi Exp

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

Synopsis [Creates the new timing box.]

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file timBox.c.

{
    Tim_Box_t * pBox;
    int i;
    if ( p->vBoxes == NULL )
        p->vBoxes = Vec_PtrAlloc( 100 );
    pBox = (Tim_Box_t *)Mem_FlexEntryFetch( p->pMemObj, sizeof(Tim_Box_t) + sizeof(int) * (nIns+nOuts) );
    memset( pBox, 0, sizeof(Tim_Box_t) );
    pBox->iBox = Vec_PtrSize( p->vBoxes );
    Vec_PtrPush( p->vBoxes, pBox );
    pBox->iDelayTable = iDelayTable;
    pBox->nInputs  = nIns;
    pBox->nOutputs = nOuts;
    for ( i = 0; i < nIns; i++ )
    {
        assert( firstIn+i < p->nCos );
        pBox->Inouts[i] = firstIn+i;
        p->pCos[firstIn+i].iObj2Box = pBox->iBox;
        p->pCos[firstIn+i].iObj2Num = i;
    }
    for ( i = 0; i < nOuts; i++ )
    {
        assert( firstOut+i < p->nCis );
        pBox->Inouts[nIns+i] = firstOut+i;
        p->pCis[firstOut+i].iObj2Box = pBox->iBox;
        p->pCis[firstOut+i].iObj2Num = i;
    }
//    if ( pBox->iBox < 20 )
//        printf( "%4d  %4d  %4d  %4d  \n", firstIn, nIns, firstOut, nOuts );
}

int Tim_ManDelayTableNum

(

Tim_Man_t *

p

)

Definition at line 715 of file timMan.c.

{
    return p->vDelayTables ? Vec_PtrSize(p->vDelayTables) : 0;
}

Tim_Man_t* Tim_ManDup	(	Tim_Man_t *	p,
		int	fUnitDelay
	)

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

Synopsis [Duplicates the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 86 of file timMan.c.

{
    Tim_Man_t * pNew;
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    float * pDelayTable, * pDelayTableNew;
    int i, k, nInputs, nOutputs;
    // clear traversal IDs
    Tim_ManForEachCi( p, pObj, i ) 
        pObj->TravId = 0;          
    Tim_ManForEachCo( p, pObj, i ) 
        pObj->TravId = 0;          
    // create new manager
    pNew = Tim_ManStart( p->nCis, p->nCos );
    // copy box connectivity information
    memcpy( pNew->pCis, p->pCis, sizeof(Tim_Obj_t) * p->nCis ); 
    memcpy( pNew->pCos, p->pCos, sizeof(Tim_Obj_t) * p->nCos ); 
    if ( fUnitDelay )
    {
        // discretize PI arrival times
//        Tim_ManForEachPi( pNew, pObj, k )
//          pObj->timeArr = (int)pObj->timeArr;
        // discretize PO required times
//        Tim_ManForEachPo( pNew, pObj, k )
//          pObj->timeReq = 1 + (int)pObj->timeReq;
        // clear PI arrival and PO required
        Tim_ManInitPiArrivalAll( p, 0.0 );
        Tim_ManInitPoRequiredAll( p, (float)TIM_ETERNITY );
    }
    // duplicate delay tables
    if ( Tim_ManDelayTableNum(p) > 0 )
    {
        pNew->vDelayTables = Vec_PtrStart( Vec_PtrSize(p->vDelayTables) );
        Tim_ManForEachTable( p, pDelayTable, i )
        {
            if ( pDelayTable == NULL )
                continue;
            assert( i == (int)pDelayTable[0] );
            nInputs   = (int)pDelayTable[1];
            nOutputs  = (int)pDelayTable[2];
            pDelayTableNew = ABC_ALLOC( float, 3 + nInputs * nOutputs );
            pDelayTableNew[0] = (int)pDelayTable[0];
            pDelayTableNew[1] = (int)pDelayTable[1];
            pDelayTableNew[2] = (int)pDelayTable[2];
            for ( k = 0; k < nInputs * nOutputs; k++ )
                if ( pDelayTable[3+k] == -ABC_INFINITY )
                    pDelayTableNew[3+k] = -ABC_INFINITY;
                else
                    pDelayTableNew[3+k] = fUnitDelay ? (float)fUnitDelay : pDelayTable[3+k];
//            assert( (int)pDelayTableNew[0] == Vec_PtrSize(pNew->vDelayTables) );
            assert( Vec_PtrEntry(pNew->vDelayTables, i) == NULL );
            Vec_PtrWriteEntry( pNew->vDelayTables, i, pDelayTableNew );
//printf( "Finished duplicating delay table %d.\n", i );
        }
    }
    // duplicate boxes
    if ( Tim_ManBoxNum(p) > 0 )
    {
        pNew->vBoxes = Vec_PtrAlloc( Tim_ManBoxNum(p) );
        Tim_ManForEachBox( p, pBox, i )
           Tim_ManCreateBox( pNew, pBox->Inouts[0], pBox->nInputs, 
                pBox->Inouts[pBox->nInputs], pBox->nOutputs, pBox->iDelayTable );
    }
    return pNew;
}

float* Tim_ManGetArrTimes

(

Tim_Man_t *

p

)

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

Synopsis [Get arrival and required times if they are non-trivial.]

Description []

SideEffects []

SeeAlso []

Definition at line 479 of file timMan.c.

{
    float * pTimes;
    Tim_Obj_t * pObj;
    int i;
    Tim_ManForEachPi( p, pObj, i )
        if ( pObj->timeArr != 0.0 )
            break;
    if ( i == Tim_ManPiNum(p) )
        return NULL;
    pTimes  = ABC_FALLOC( float, Tim_ManCiNum(p) );
    Tim_ManForEachPi( p, pObj, i )
        pTimes[i] = pObj->timeArr;
    return pTimes;
}

float Tim_ManGetCiArrival	(	Tim_Man_t *	p,
		int	iCi
	)

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

Synopsis [Returns CO arrival time.]

Description []

SideEffects []

SeeAlso []

Definition at line 174 of file timTime.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObjThis, * pObj, * pObjRes;
    float * pTable, * pDelays, DelayBest;
    int i, k;
    // consider the already processed PI
    pObjThis = Tim_ManCi( p, iCi );
    if ( p->fUseTravId && pObjThis->TravId == p->nTravIds )
        return pObjThis->timeArr;
    pObjThis->TravId = p->nTravIds;
    // consider the main PI
    pBox = Tim_ManCiBox( p, iCi );
    if ( pBox == NULL )
        return pObjThis->timeArr;
    // update box timing
    pBox->TravId = p->nTravIds;
    // get the arrival times of the inputs of the box (POs)
    if ( p->fUseTravId )
    Tim_ManBoxForEachInput( p, pBox, pObj, i )
        if ( pObj->TravId != p->nTravIds )
            printf( "Tim_ManGetCiArrival(): Input arrival times of the box are not up to date!\n" );
    // compute the arrival times for each output of the box (PIs)
    pTable = Tim_ManBoxDelayTable( p, pBox->iBox );
    Tim_ManBoxForEachOutput( p, pBox, pObjRes, i )
    {
        pDelays = pTable + 3 + i * pBox->nInputs;
        DelayBest = -TIM_ETERNITY;
        Tim_ManBoxForEachInput( p, pBox, pObj, k )
            if ( pDelays[k] != -ABC_INFINITY )
                DelayBest = Abc_MaxInt( DelayBest, pObj->timeArr + pDelays[k] );
        pObjRes->timeArr = DelayBest;
        pObjRes->TravId = p->nTravIds;
    }
    return pObjThis->timeArr;
}

float Tim_ManGetCoRequired	(	Tim_Man_t *	p,
		int	iCo
	)

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

Synopsis [Returns CO required time.]

Description []

SideEffects []

SeeAlso []

Definition at line 222 of file timTime.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObjThis, * pObj, * pObjRes;
    float * pTable, * pDelays, DelayBest;
    int i, k;
    // consider the already processed PO
    pObjThis = Tim_ManCo( p, iCo );
    if ( p->fUseTravId && pObjThis->TravId == p->nTravIds )
        return pObjThis->timeReq;
    pObjThis->TravId = p->nTravIds;
    // consider the main PO
    pBox = Tim_ManCoBox( p, iCo );
    if ( pBox == NULL )
        return pObjThis->timeReq;
    // update box timing
    pBox->TravId = p->nTravIds;
    // get the required times of the outputs of the box (PIs)
    if ( p->fUseTravId )
    Tim_ManBoxForEachOutput( p, pBox, pObj, i )
        if ( pObj->TravId != p->nTravIds )
            printf( "Tim_ManGetCoRequired(): Output required times of output %d the box %d are not up to date!\n", i, pBox->iBox );
    // compute the required times for each input of the box (POs)
    pTable = Tim_ManBoxDelayTable( p, pBox->iBox );
    Tim_ManBoxForEachInput( p, pBox, pObjRes, i )
    {
        DelayBest = TIM_ETERNITY;
        Tim_ManBoxForEachOutput( p, pBox, pObj, k )
        {
            pDelays = pTable + 3 + k * pBox->nInputs;
            if ( pDelays[k] != -ABC_INFINITY )
                DelayBest = Abc_MinFloat( DelayBest, pObj->timeReq - pDelays[i] );
        }
        pObjRes->timeReq = DelayBest;
        pObjRes->TravId = p->nTravIds;
    }
    return pObjThis->timeReq;
}

float* Tim_ManGetReqTimes

(

Tim_Man_t *

p

)

Definition at line 494 of file timMan.c.

{
    float * pTimes;
    Tim_Obj_t * pObj;
    int i, k = 0;
    Tim_ManForEachPo( p, pObj, i )
        if ( pObj->timeReq != TIM_ETERNITY )
            break;
    if ( i == Tim_ManPoNum(p) )
        return NULL;
    pTimes  = ABC_FALLOC( float, Tim_ManCoNum(p) );
    Tim_ManForEachPo( p, pObj, i )
        pTimes[k++] = pObj->timeArr;
    assert( k == Tim_ManPoNum(p) );
    return pTimes;
}

void Tim_ManIncrementTravId

(

Tim_Man_t *

p

)

DECLARATIONS ///.

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

FileName [timTrav.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchy/timing manager.]

Synopsis [Manipulation of traversal IDs.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - April 28, 2007.]

Revision [

Id:

timTrav.c,v 1.00 2007/04/28 00:00:00 alanmi Exp

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

Synopsis [Increments the trav ID of the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file timTrav.c.

{
    int i;
    if ( p->nTravIds >= (1<<30)-1 )
    {
        p->nTravIds = 0;
        for ( i = 0; i < p->nCis; i++ )
            p->pCis[i].TravId = 0;
        for ( i = 0; i < p->nCos; i++ )
            p->pCos[i].TravId = 0;
    }
    assert( p->nTravIds < (1<<30)-1 );
    p->nTravIds++;
}

void Tim_ManInitPiArrival	(	Tim_Man_t *	p,
		int	iPi,
		float	Delay
	)

DECLARATIONS ///.

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

FileName [timTime.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchy/timing manager.]

Synopsis [Setting and resetting timing information of the boxes.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - April 28, 2007.]

Revision [

Id:

timTime.c,v 1.00 2007/04/28 00:00:00 alanmi Exp

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

Synopsis [Initializes arrival time of the PI.]

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file timTime.c.

{
    assert( iPi < p->nCis );
    p->pCis[iPi].timeArr = Delay;
}

void Tim_ManInitPiArrivalAll	(	Tim_Man_t *	p,
		float	Delay
	)

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

Synopsis [Sets arrival times of all PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 78 of file timTime.c.

{
    Tim_Obj_t * pObj;
    int i;
    Tim_ManForEachPi( p, pObj, i )
        Tim_ManInitPiArrival( p, i, Delay );
}

void Tim_ManInitPoRequired	(	Tim_Man_t *	p,
		int	iPo,
		float	Delay
	)

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

Synopsis [Initializes required time of the PO.]

Description []

SideEffects []

SeeAlso []

Definition at line 61 of file timTime.c.

{
    assert( iPo < p->nCos );
    p->pCos[iPo].timeReq = Delay;
}

void Tim_ManInitPoRequiredAll	(	Tim_Man_t *	p,
		float	Delay
	)

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

Synopsis [Sets required times of all POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 97 of file timTime.c.

{
    Tim_Obj_t * pObj;
    int i;
    Tim_ManForEachPo( p, pObj, i )
        Tim_ManSetCoRequired( p, i, Delay );
}

int Tim_ManIsCiTravIdCurrent	(	Tim_Man_t *	p,
		int	iCi
	)

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

Synopsis [Updates required time of the CI.]

Description []

SideEffects []

SeeAlso []

Definition at line 154 of file timTrav.c.

{
    assert( iCi < p->nCis );
    assert( p->fUseTravId );
    return p->pCis[iCi].TravId == p->nTravIds;
}

int Tim_ManIsCoTravIdCurrent	(	Tim_Man_t *	p,
		int	iCo
	)

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

Synopsis [Updates required time of the CO.]

Description []

SideEffects []

SeeAlso []

Definition at line 172 of file timTrav.c.

{
    assert( iCo < p->nCos );
    assert( p->fUseTravId );
    return p->pCos[iCo].TravId == p->nTravIds;
}

Tim_Man_t* Tim_ManLoad	(	Vec_Str_t *	p,
		int	fHieOnly
	)

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

Synopsis [Restores the timing manager from the char stream.]

Description []

SideEffects []

SeeAlso []

Definition at line 112 of file timDump.c.

{
    Tim_Man_t * pMan;
    Tim_Obj_t * pObj;
    int VerNum, nCis, nCos, nPis, nPos;
    int nBoxes, nBoxIns, nBoxOuts, CopyBox;
    int TableId, nTables, TableSize, TableX, TableY;
    int i, k, curPi, curPo, iStr = 0;
    float * pDelayTable;
    // get version number 
    VerNum = Vec_StrGetI_ne( p, &iStr );
    assert( VerNum == TIM_DUMP_VER_NUM );
    // get the number of CIs/COs
    nCis = Vec_StrGetI_ne( p, &iStr );
    nCos = Vec_StrGetI_ne( p, &iStr );
    // get the number of PIs/POs
    nPis = Vec_StrGetI_ne( p, &iStr );
    nPos = Vec_StrGetI_ne( p, &iStr );
    // start the timing manager
    pMan = Tim_ManStart( nCis, nCos );
    // start boxes
    nBoxes = Vec_StrGetI_ne( p, &iStr );
    assert( pMan->vBoxes == NULL );
    if ( nBoxes > 0 )
        pMan->vBoxes = Vec_PtrAlloc( nBoxes );
    // create boxes
    curPi = nPis;
    curPo = 0;
    for ( i = 0; i < nBoxes; i++ )
    {
        nBoxIns  = Vec_StrGetI_ne( p, &iStr );
        nBoxOuts = Vec_StrGetI_ne( p, &iStr );
        TableId  = Vec_StrGetI_ne( p, &iStr );
        CopyBox  = Vec_StrGetI_ne( p, &iStr );
        Tim_ManCreateBox( pMan, curPo, nBoxIns, curPi, nBoxOuts, TableId );
        Tim_ManBoxSetCopy( pMan, i, CopyBox );
        curPi += nBoxOuts;
        curPo += nBoxIns;
    }
    curPo += nPos;
    assert( curPi == nCis );
    assert( curPo == nCos );
    if ( fHieOnly )
        return pMan;
    // create delay tables
    nTables = Vec_StrGetI_ne( p, &iStr );
    assert( pMan->vDelayTables == NULL );
    if ( nTables > 0 )
        pMan->vDelayTables = Vec_PtrAlloc( nTables );
    // read delay tables
    for ( i = 0; i < nTables; i++ )
    {
        // read table ID and dimensions
        TableId = Vec_StrGetI_ne( p, &iStr );
        TableX  = Vec_StrGetI_ne( p, &iStr );
        TableY  = Vec_StrGetI_ne( p, &iStr );
        assert( TableId == i );
        // create new table
        TableSize = TableX * TableY;
        pDelayTable = ABC_ALLOC( float, TableSize + 3 );
        pDelayTable[0] = TableId;
        pDelayTable[1] = TableX;
        pDelayTable[2] = TableY;
        // read table contents
        for ( k = 0; k < TableSize; k++ )
            pDelayTable[k+3] = Vec_StrGetF( p, &iStr );
        assert( Vec_PtrSize(pMan->vDelayTables) == TableId );
        Vec_PtrPush( pMan->vDelayTables, pDelayTable );
    }
    assert( Tim_ManDelayTableNum(pMan) == nTables );
    // read PI arrival times
    Tim_ManForEachPi( pMan, pObj, i )
        Tim_ManInitPiArrival( pMan, i, Vec_StrGetF(p, &iStr) );
    // read PO required times
    Tim_ManForEachPo( pMan, pObj, i )
        Tim_ManInitPoRequired( pMan, i, Vec_StrGetF(p, &iStr) );
    assert( Vec_StrSize(p) == iStr );
//    Tim_ManPrint( pMan );
    return pMan;
}

int Tim_ManPiNum

(

Tim_Man_t *

p

)

Definition at line 688 of file timMan.c.

{
    if ( Tim_ManBoxNum(p) == 0 )
        return Tim_ManCiNum(p);
    return Tim_ManBoxOutputFirst(p, 0);
}

int Tim_ManPoNum

(

Tim_Man_t *

p

)

Definition at line 694 of file timMan.c.

{
    int iLastBoxId;
    if ( Tim_ManBoxNum(p) == 0 )
        return Tim_ManCoNum(p);
    iLastBoxId = Tim_ManBoxNum(p) - 1;
    return Tim_ManCoNum(p) - (Tim_ManBoxInputFirst(p, iLastBoxId) + Tim_ManBoxInputNum(p, iLastBoxId));
}

void Tim_ManPrint

(

Tim_Man_t *

p

)

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

Synopsis [Prints the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 523 of file timMan.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj, * pPrev;
    float * pTable;
    int i, j, k, TableX, TableY;
    if ( p == NULL )
        return;
    printf( "TIMING MANAGER:\n" );
    printf( "PI = %d. CI = %d. PO = %d. CO = %d. Box = %d.\n", 
        Tim_ManPiNum(p), Tim_ManCiNum(p), Tim_ManPoNum(p), Tim_ManCoNum(p), Tim_ManBoxNum(p) );

    // print CI info
    pPrev = p->pCis;
    Tim_ManForEachPi( p, pObj, i )
        if ( pPrev->timeArr != pObj->timeArr || pPrev->timeReq != pObj->timeReq )
            break;
    if ( i == Tim_ManCiNum(p) )
        printf( "All PIs     :  arrival = %5.3f  required = %5.3f\n", pPrev->timeArr, pPrev->timeReq );
    else
        Tim_ManForEachPi( p, pObj, i )
            printf( "PI%5d     :  arrival = %5.3f  required = %5.3f\n", i, pObj->timeArr, pObj->timeReq );

    // print CO info
    pPrev = p->pCos;
    Tim_ManForEachPo( p, pObj, i )
        if ( pPrev->timeArr != pObj->timeArr || pPrev->timeReq != pObj->timeReq )
            break;
    if ( i == Tim_ManCoNum(p) )
        printf( "All POs     :  arrival = %5.3f  required = %5.3f\n", pPrev->timeArr, pPrev->timeReq );
    else
    {
        int k = 0;
        Tim_ManForEachPo( p, pObj, i )
            printf( "PO%5d     :  arrival = %5.3f  required = %5.3f\n", k++, pObj->timeArr, pObj->timeReq );
    }

    // print box info
    if ( Tim_ManBoxNum(p) > 0 )
    Tim_ManForEachBox( p, pBox, i )
    {
        printf( "*** Box %5d :  I =%4d. O =%4d. I1 =%6d. O1 =%6d. Table =%4d\n", 
            i, pBox->nInputs, pBox->nOutputs, 
            Tim_ManBoxInputFirst(p, i), Tim_ManBoxOutputFirst(p, i), 
            pBox->iDelayTable );

        // print box inputs
        pPrev = Tim_ManBoxInput( p, pBox, 0 );
        Tim_ManBoxForEachInput( p, pBox, pObj, k )
            if ( pPrev->timeArr != pObj->timeArr || pPrev->timeReq != pObj->timeReq )
                break;
        if ( k == Tim_ManBoxInputNum(p, pBox->iBox) )
            printf( "Box inputs  :  arrival = %5.3f  required = %5.3f\n", pPrev->timeArr, pPrev->timeReq );
        else
            Tim_ManBoxForEachInput( p, pBox, pObj, k )
                printf( "box-in%4d :  arrival = %5.3f  required = %5.3f\n", k, pObj->timeArr, pObj->timeReq );

        // print box outputs
        pPrev = Tim_ManBoxOutput( p, pBox, 0 );
        Tim_ManBoxForEachOutput( p, pBox, pObj, k )
            if ( pPrev->timeArr != pObj->timeArr || pPrev->timeReq != pObj->timeReq )
                break;
        if ( k == Tim_ManBoxOutputNum(p, pBox->iBox) )
            printf( "Box outputs :  arrival = %5.3f  required = %5.3f\n", pPrev->timeArr, pPrev->timeReq );
        else
            Tim_ManBoxForEachOutput( p, pBox, pObj, k )
                printf( "box-out%3d :  arrival = %5.3f  required = %5.3f\n", k, pObj->timeArr, pObj->timeReq );

        if ( i > 2 )
            break;
    }

    // print delay tables
    if ( Tim_ManDelayTableNum(p) > 0 )
    Tim_ManForEachTable( p, pTable, i )
    {
        if ( pTable == NULL )
            continue;
        printf( "Delay table %d:\n", i );
        assert( i == (int)pTable[0] );
        TableX = (int)pTable[1];
        TableY = (int)pTable[2];
        for ( j = 0; j < TableY; j++, printf( "\n" ) )
            for ( k = 0; k < TableX; k++ )
                if ( pTable[3+j*TableX+k] == -ABC_INFINITY )
                    printf( "%5s", "-" );
                else
                    printf( "%5.0f", pTable[3+j*TableX+k] );
    }
    printf( "\n" );
}

void Tim_ManPrintStats	(	Tim_Man_t *	p,
		int	nAnd2Delay
	)

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

Synopsis [Prints statistics of the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 626 of file timMan.c.

{
    Tim_Box_t * pBox;
    Vec_Int_t * vCounts;
    Vec_Ptr_t * vBoxes;
    int i, Count, IdMax;
    if ( p == NULL )
        return;
    Abc_Print( 1, "Hierarchy      :  " );
    printf( "PI/CI = %d/%d   PO/CO = %d/%d   Box = %d   ", 
        Tim_ManPiNum(p), Tim_ManCiNum(p), 
        Tim_ManPoNum(p), Tim_ManCoNum(p), 
        Tim_ManBoxNum(p) );
    if ( nAnd2Delay )
        printf( "delay(AND2) = %d", nAnd2Delay );
    printf( "\n" );
    if ( Tim_ManBoxNum(p) == 0 )
        return;
    IdMax = 0;
    Tim_ManForEachBox( p, pBox, i )
        IdMax = Abc_MaxInt( IdMax, pBox->iDelayTable );
    vCounts = Vec_IntStart( IdMax+1 );
    vBoxes  = Vec_PtrStart( IdMax+1 );
    Tim_ManForEachBox( p, pBox, i )
    {
        Vec_IntAddToEntry( vCounts, pBox->iDelayTable, 1 );
        Vec_PtrWriteEntry( vBoxes, pBox->iDelayTable, pBox );
    }
    // print statistics about boxes
    Vec_IntForEachEntry( vCounts, Count, i )
    {
        if ( Count == 0 ) continue;
        pBox = (Tim_Box_t *)Vec_PtrEntry( vBoxes, i );
        printf( "    Box %4d      ", i );
        printf( "Num = %4d   ", Count );
        printf( "Ins = %4d   ", pBox->nInputs );
        printf( "Outs = %4d",   pBox->nOutputs );
        printf( "\n" );
    }
    Vec_IntFree( vCounts );
    Vec_PtrFree( vBoxes );
}

Tim_Man_t* Tim_ManReduce	(	Tim_Man_t *	p,
		Vec_Int_t *	vBoxesLeft,
		int	nTermsDiff
	)

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

Synopsis [Reduces the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 251 of file timMan.c.

{
    Tim_Man_t * pNew;
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    float * pDelayTable, * pDelayTableNew;
    int i, k, iBox, nNewCis, nNewCos, nInputs, nOutputs;
    int nNewPiNum = Tim_ManPiNum(p) - nTermsDiff;
    int nNewPoNum = Tim_ManPoNum(p) - nTermsDiff;
    assert( Vec_IntSize(vBoxesLeft) <= Tim_ManBoxNum(p) );
    // count the number of CIs and COs in the trimmed manager
    nNewCis = nNewPiNum;
    nNewCos = nNewPoNum;
    Vec_IntForEachEntry( vBoxesLeft, iBox, i )
    {
        pBox = Tim_ManBox( p, iBox );
        nNewCis += pBox->nOutputs;
        nNewCos += pBox->nInputs;
    }
    assert( nNewCis <= Tim_ManCiNum(p) - nTermsDiff );
    assert( nNewCos <= Tim_ManCoNum(p) - nTermsDiff );
    // clear traversal IDs
    Tim_ManForEachCi( p, pObj, i ) 
        pObj->TravId = 0;          
    Tim_ManForEachCo( p, pObj, i ) 
        pObj->TravId = 0;          
    // create new manager
    pNew = Tim_ManStart( nNewCis, nNewCos );
    // copy box connectivity information
    memcpy( pNew->pCis, p->pCis, sizeof(Tim_Obj_t) * nNewPiNum );
    memcpy( pNew->pCos + nNewCos - nNewPoNum, 
            p->pCos + Tim_ManCoNum(p) - Tim_ManPoNum(p), 
            sizeof(Tim_Obj_t) * nNewPoNum );
    // duplicate delay tables
    if ( Tim_ManDelayTableNum(p) > 0 )
    {
        int fWarning = 0;
        pNew->vDelayTables = Vec_PtrStart( Vec_PtrSize(p->vDelayTables) );
        Tim_ManForEachTable( p, pDelayTable, i )
        {
            if ( pDelayTable == NULL )
                continue;
            if ( i != (int)pDelayTable[0] && fWarning == 0 )
            {
                printf( "Warning: Mismatch in delay-table number between the manager and the box.\n" );
                fWarning = 1;
            }
            //assert( i == (int)pDelayTable[0] );
            nInputs   = (int)pDelayTable[1];
            nOutputs  = (int)pDelayTable[2];
            pDelayTableNew = ABC_ALLOC( float, 3 + nInputs * nOutputs );
            pDelayTableNew[0] = i;//(int)pDelayTable[0];
            pDelayTableNew[1] = (int)pDelayTable[1];
            pDelayTableNew[2] = (int)pDelayTable[2];
            for ( k = 0; k < nInputs * nOutputs; k++ )
                pDelayTableNew[3+k] = pDelayTable[3+k];
//            assert( (int)pDelayTableNew[0] == Vec_PtrSize(pNew->vDelayTables) );
            assert( Vec_PtrEntry(pNew->vDelayTables, i) == NULL );
            Vec_PtrWriteEntry( pNew->vDelayTables, i, pDelayTableNew );
        }
    }
    // duplicate boxes
    if ( Tim_ManBoxNum(p) > 0 )
    {
        int curPi = nNewPiNum;
        int curPo = 0;
        pNew->vBoxes = Vec_PtrAlloc( Tim_ManBoxNum(p) );
        Vec_IntForEachEntry( vBoxesLeft, iBox, i )
        {
            pBox = Tim_ManBox( p, iBox );
            Tim_ManCreateBox( pNew, curPo, pBox->nInputs, curPi, pBox->nOutputs, pBox->iDelayTable );
            Tim_ManBoxSetCopy( pNew, Tim_ManBoxNum(pNew) - 1, iBox );
            curPi += pBox->nOutputs;
            curPo += pBox->nInputs;
        }
        curPo += nNewPoNum;
        assert( curPi == Tim_ManCiNum(pNew) );
        assert( curPo == Tim_ManCoNum(pNew) );
    }
    return pNew;
}

Vec_Str_t* Tim_ManSave	(	Tim_Man_t *	p,
		int	fHieOnly
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Transform the timing manager into the char stream.]

Description []

SideEffects []

SeeAlso []

Definition at line 46 of file timDump.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    Vec_Str_t * vStr;
    float * pDelayTable;
    int i, k, TableSize;
    // create output stream
    vStr = Vec_StrAlloc( 10000 );
    // dump version number
    Vec_StrPutI_ne( vStr, TIM_DUMP_VER_NUM );
    // save CI/CO counts
    Vec_StrPutI_ne( vStr, Tim_ManCiNum(p) );
    Vec_StrPutI_ne( vStr, Tim_ManCoNum(p) );
    // save PI/PO counts
    Vec_StrPutI_ne( vStr, Tim_ManPiNum(p) );
    Vec_StrPutI_ne( vStr, Tim_ManPoNum(p) );
    // save number of boxes
    Vec_StrPutI_ne( vStr, Tim_ManBoxNum(p) );
    // for each box, save num_inputs, num_outputs, delay table ID, and copy field
    if ( Tim_ManBoxNum(p) > 0 )
    Tim_ManForEachBox( p, pBox, i )
    {
        Vec_StrPutI_ne( vStr, Tim_ManBoxInputNum(p, pBox->iBox) );
        Vec_StrPutI_ne( vStr, Tim_ManBoxOutputNum(p, pBox->iBox) );
        Vec_StrPutI_ne( vStr, Tim_ManBoxDelayTableId(p, pBox->iBox) ); // can be -1 if delay table is not given
        Vec_StrPutI_ne( vStr, Tim_ManBoxCopy(p, pBox->iBox) );         // can be -1 if the copy is node defined
    }
    if ( fHieOnly )
        return vStr;
    // save the number of delay tables
    Vec_StrPutI_ne( vStr, Tim_ManDelayTableNum(p) );
    // save the delay tables
    if ( Tim_ManDelayTableNum(p) > 0 )
    Tim_ManForEachTable( p, pDelayTable, i )
    {
        assert( (int)pDelayTable[0] == i );
        // save table ID and dimensions (inputs x outputs)
        Vec_StrPutI_ne( vStr, (int)pDelayTable[0] );
        Vec_StrPutI_ne( vStr, (int)pDelayTable[1] );
        Vec_StrPutI_ne( vStr, (int)pDelayTable[2] );
        // save table contents
        TableSize = (int)pDelayTable[1] * (int)pDelayTable[2];
        for ( k = 0; k < TableSize; k++ )
            Vec_StrPutF( vStr, pDelayTable[k+3] );
    }
    // save PI arrival times
    Tim_ManForEachPi( p, pObj, i )
        Vec_StrPutF( vStr, Tim_ManGetCiArrival(p, pObj->Id) );
    // save PO required times
    Tim_ManForEachPo( p, pObj, i )
        Vec_StrPutF( vStr, Tim_ManGetCoRequired(p, pObj->Id) );
    return vStr;
}

void Tim_ManSetCiRequired	(	Tim_Man_t *	p,
		int	iCi,
		float	Delay
	)

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

Synopsis [Updates required time of the CI.]

Description []

SideEffects []

SeeAlso []

Definition at line 135 of file timTime.c.

{
    assert( iCi < p->nCis );
    assert( !p->fUseTravId || p->pCis[iCi].TravId != p->nTravIds );
    p->pCis[iCi].timeReq = Delay;
    p->pCis[iCi].TravId = p->nTravIds;
}

void Tim_ManSetCoArrival	(	Tim_Man_t *	p,
		int	iCo,
		float	Delay
	)

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

Synopsis [Updates arrival time of the CO.]

Description []

SideEffects []

SeeAlso []

Definition at line 116 of file timTime.c.

{
    assert( iCo < p->nCos );
    assert( !p->fUseTravId || p->pCos[iCo].TravId != p->nTravIds );
    p->pCos[iCo].timeArr = Delay;
    p->pCos[iCo].TravId = p->nTravIds;
}

void Tim_ManSetCoRequired	(	Tim_Man_t *	p,
		int	iCo,
		float	Delay
	)

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

Synopsis [Updates required time of the CO.]

Description []

SideEffects []

SeeAlso []

Definition at line 154 of file timTime.c.

{
    assert( iCo < p->nCos );
    assert( !p->fUseTravId || !p->nTravIds || p->pCos[iCo].TravId != p->nTravIds );
    p->pCos[iCo].timeReq = Delay;
    p->pCos[iCo].TravId = p->nTravIds;
}

void Tim_ManSetCurrentTravIdBoxInputs	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Label box inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 70 of file timTrav.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    int i;
    pBox = Tim_ManBox( p, iBox );
    Tim_ManBoxForEachInput( p, pBox, pObj, i )
        pObj->TravId = p->nTravIds;
}

void Tim_ManSetCurrentTravIdBoxOutputs	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Label box outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 91 of file timTrav.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    int i;
    pBox = Tim_ManBox( p, iBox );
    Tim_ManBoxForEachOutput( p, pBox, pObj, i )
        pObj->TravId = p->nTravIds;
}

void Tim_ManSetDelayTables	(	Tim_Man_t *	p,
		Vec_Ptr_t *	vDelayTables
	)

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

Synopsis [Sets the vector of timing tables associated with the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 731 of file timMan.c.

{
    assert( p->vDelayTables == NULL );
    p->vDelayTables = vDelayTables;
}

void Tim_ManSetPreviousTravIdBoxInputs	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Label box inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 112 of file timTrav.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    int i;
    pBox = Tim_ManBox( p, iBox );
    Tim_ManBoxForEachInput( p, pBox, pObj, i )
        pObj->TravId = p->nTravIds - 1;
}

void Tim_ManSetPreviousTravIdBoxOutputs	(	Tim_Man_t *	p,
		int	iBox
	)

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

Synopsis [Label box outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 133 of file timTrav.c.

{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    int i;
    pBox = Tim_ManBox( p, iBox );
    Tim_ManBoxForEachOutput( p, pBox, pObj, i )
        pObj->TravId = p->nTravIds - 1;
}

Tim_Man_t* Tim_ManStart	(	int	nCis,
		int	nCos
	)

DECLARATIONS ///.

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

FileName [timMan.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchy/timing manager.]

Synopsis [Manipulation of manager data-structure.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - April 28, 2007.]

Revision [

Id:

timMan.c,v 1.00 2007/04/28 00:00:00 alanmi Exp

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

Synopsis [Starts the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file timMan.c.

{
    Tim_Man_t * p;
    Tim_Obj_t * pObj;
    int i;
    p = ABC_ALLOC( Tim_Man_t, 1 );
    memset( p, 0, sizeof(Tim_Man_t) );
    p->pMemObj = Mem_FlexStart();
    p->nCis = nCis;
    p->nCos = nCos;
    p->pCis = ABC_ALLOC( Tim_Obj_t, nCis );
    memset( p->pCis, 0, sizeof(Tim_Obj_t) * nCis );
    p->pCos = ABC_ALLOC( Tim_Obj_t, nCos );
    memset( p->pCos, 0, sizeof(Tim_Obj_t) * nCos );
    Tim_ManForEachCi( p, pObj, i )
    {
        pObj->Id = i;
        pObj->iObj2Box = pObj->iObj2Num = -1;
        pObj->timeReq = TIM_ETERNITY;
    }
    Tim_ManForEachCo( p, pObj, i )
    {
        pObj->Id = i;
        pObj->iObj2Box = pObj->iObj2Num = -1;
        pObj->timeReq = TIM_ETERNITY;
    }
    p->fUseTravId = 1;
    return p;
}

void Tim_ManStop

(

Tim_Man_t *

p

)

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

Synopsis [Stops the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 375 of file timMan.c.

{
    Vec_PtrFreeFree( p->vDelayTables );
    Vec_PtrFreeP( &p->vBoxes );
    Mem_FlexStop( p->pMemObj, 0 );
    ABC_FREE( p->pCis );
    ABC_FREE( p->pCos );
    ABC_FREE( p );
}

void Tim_ManStopP

(

Tim_Man_t **

p

)

Definition at line 384 of file timMan.c.

{
    if ( *p == NULL )
        return;
    Tim_ManStop( *p );
    *p = NULL;
}

void Tim_ManTravIdDisable

(

Tim_Man_t *

p

)

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

Synopsis [Disables the use of the traversal ID.]

Description []

SideEffects []

SeeAlso []

Definition at line 748 of file timMan.c.

{
    p->fUseTravId = 0;
}

void Tim_ManTravIdEnable

(

Tim_Man_t *

p

)

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

Synopsis [Enables the use of the traversal ID.]

Description []

SideEffects []

SeeAlso []

Definition at line 764 of file timMan.c.

{
    p->fUseTravId = 1;
}

Tim_Man_t* Tim_ManTrim	(	Tim_Man_t *	p,
		Vec_Int_t *	vBoxPres
	)

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

Synopsis [Trims the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 163 of file timMan.c.

{
    Tim_Man_t * pNew;
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    float * pDelayTable, * pDelayTableNew;
    int i, k, nNewCis, nNewCos, nInputs, nOutputs;
    assert( Vec_IntSize(vBoxPres) == Tim_ManBoxNum(p) );
    // count the number of CIs and COs in the trimmed manager
    nNewCis = Tim_ManPiNum(p);
    nNewCos = Tim_ManPoNum(p);
    if ( Tim_ManBoxNum(p) )
        Tim_ManForEachBox( p, pBox, i )
            if ( Vec_IntEntry(vBoxPres, i) )
            {
                nNewCis += pBox->nOutputs;
                nNewCos += pBox->nInputs;
            }
    if ( nNewCis == Tim_ManCiNum(p) && nNewCos == Tim_ManCoNum(p) )
        return Tim_ManDup( p, 0 );
    assert( nNewCis < Tim_ManCiNum(p) );
    assert( nNewCos < Tim_ManCoNum(p) );
    // clear traversal IDs
    Tim_ManForEachCi( p, pObj, i ) 
        pObj->TravId = 0;          
    Tim_ManForEachCo( p, pObj, i ) 
        pObj->TravId = 0;          
    // create new manager
    pNew = Tim_ManStart( nNewCis, nNewCos );
    // copy box connectivity information
    memcpy( pNew->pCis, p->pCis, sizeof(Tim_Obj_t) * Tim_ManPiNum(p) );
    memcpy( pNew->pCos + nNewCos - Tim_ManPoNum(p), 
            p->pCos + Tim_ManCoNum(p) - Tim_ManPoNum(p), 
            sizeof(Tim_Obj_t) * Tim_ManPoNum(p) );
    // duplicate delay tables
    if ( Tim_ManDelayTableNum(p) > 0 )
    {
        pNew->vDelayTables = Vec_PtrStart( Vec_PtrSize(p->vDelayTables) );
        Tim_ManForEachTable( p, pDelayTable, i )
        {
            if ( pDelayTable == NULL )
                continue;
            assert( i == (int)pDelayTable[0] );
            nInputs   = (int)pDelayTable[1];
            nOutputs  = (int)pDelayTable[2];
            pDelayTableNew = ABC_ALLOC( float, 3 + nInputs * nOutputs );
            pDelayTableNew[0] = (int)pDelayTable[0];
            pDelayTableNew[1] = (int)pDelayTable[1];
            pDelayTableNew[2] = (int)pDelayTable[2];
            for ( k = 0; k < nInputs * nOutputs; k++ )
                pDelayTableNew[3+k] = pDelayTable[3+k];
//            assert( (int)pDelayTableNew[0] == Vec_PtrSize(pNew->vDelayTables) );
            assert( Vec_PtrEntry(pNew->vDelayTables, i) == NULL );
            Vec_PtrWriteEntry( pNew->vDelayTables, i, pDelayTableNew );
        }
    }
    // duplicate boxes
    if ( Tim_ManBoxNum(p) > 0 )
    {
        int curPi = Tim_ManPiNum(p);
        int curPo = 0;
        pNew->vBoxes = Vec_PtrAlloc( Tim_ManBoxNum(p) );
        Tim_ManForEachBox( p, pBox, i )
            if ( Vec_IntEntry(vBoxPres, i) )
            {
                Tim_ManCreateBox( pNew, curPo, pBox->nInputs, curPi, pBox->nOutputs, pBox->iDelayTable );
                Tim_ManBoxSetCopy( pNew, Tim_ManBoxNum(pNew) - 1, i );
                curPi += pBox->nOutputs;
                curPo += pBox->nInputs;
            }
        curPo += Tim_ManPoNum(p);
        assert( curPi == Tim_ManCiNum(pNew) );
        assert( curPo == Tim_ManCoNum(pNew) );
    }
    return pNew;
}