giaSif.c File Reference

#include "gia.h"

Include dependency graph for giaSif.c:

Go to the source code of this file.

Functions
ABC_NAMESPACE_IMPL_START void	Gia_ManSifDupNode_rec (Gia_Man_t *pNew, Gia_Man_t *p, Gia_Obj_t *pObj)
	DECLARATIONS ///.
void	Gia_ManSifDupNode (Gia_Man_t *pNew, Gia_Man_t *p, int iObj, Vec_Int_t *vCopy)
Vec_Int_t *	Gia_ManSifInitNeg (Gia_Man_t *p, Vec_Int_t *vMoves, Vec_Int_t *vRegs)
Vec_Int_t *	Gia_ManSifInitPos (Gia_Man_t *p, Vec_Int_t *vMoves, Vec_Int_t *vRegs)
Gia_Man_t *	Gia_ManSifDerive (Gia_Man_t *p, Vec_Int_t *vCounts, int fVerbose)
int	Gia_ManSifArea_rec (Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vCuts, int nSize)
int	Gia_ManSifArea (Gia_Man_t *p, Vec_Int_t *vCuts, int nSize)
int	Gia_ManSifDelay_rec (Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nSize)
int	Gia_ManSifDelay (Gia_Man_t *p, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nSize)
Vec_Int_t *	Gia_ManSifTimesToCounts (Gia_Man_t *p, Vec_Int_t *vTimes, int Period)
Gia_Man_t *	Gia_ManSifTransform (Gia_Man_t *p, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nLutSize, int Period, int fVerbose)
int	Gia_ManSifCheckIter (Gia_Man_t *p, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nLutSize, int Period)
int	Gia_ManSifCheckPeriod (Gia_Man_t *p, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nLutSize, int Period, int *pIters)
int	Gia_ManSifMapComb (Gia_Man_t *p, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nLutSize)
void	Gia_ManSifPrintTimes (Gia_Man_t *p, Vec_Int_t *vTimes, int Period)
int	Gia_ManSifDeriveMapping_rec (Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vCuts, int nSize)
int	Gia_ManSifDeriveMapping (Gia_Man_t *p, Vec_Int_t *vCuts, Vec_Int_t *vTimes, int nLutSize, int Period, int fVerbose)
Gia_Man_t *	Gia_ManSifPerform (Gia_Man_t *p, int nLutSize, int fEvalOnly, int fVerbose)

Function Documentation

Gia_ManSifArea()

int Gia_ManSifArea	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		int	nSize )

Definition at line 313 of file giaSif.c.

{
    Gia_Obj_t * pObj; int i, nArea = 0;
    Gia_ManIncrementTravId( p );
    Gia_ManForEachCo( p, pObj, i )
        nArea += Gia_ManSifArea_rec( p, Gia_ObjFanin0(pObj), vCuts, nSize );
    return nArea;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifArea_rec()

int Gia_ManSifArea_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vCuts,
		int	nSize )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 301 of file giaSif.c.

{
    int i, * pCut, Area = 1;
    if ( Gia_ObjUpdateTravIdCurrent(p, pObj) )
        return 0;
    if ( !Gia_ObjIsAnd(pObj) )
        return 0;
    pCut = Vec_IntEntryP( vCuts, Gia_ObjId(p, pObj)*nSize );
    for ( i = 1; i <= pCut[0]; i++ )
        Area += Gia_ManSifArea_rec( p, Gia_ManObj(p, pCut[i] >> 8), vCuts, nSize );
    return Area;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifCheckIter()

int Gia_ManSifCheckIter	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nLutSize,
		int	Period )

Definition at line 475 of file giaSif.c.

{
    int i, fChange = 0, nSize = nLutSize+1;
    Gia_Obj_t * pObj, * pObjRi, * pObjRo; 
    Gia_ManForEachAnd( p, pObj, i )
        fChange |= Gia_ManSifCutOne( p, i, vCuts, vTimes, nSize );
    Gia_ManForEachCo( p, pObj, i )
        Vec_IntWriteEntry( vTimes, Gia_ObjId(p, pObj), Vec_IntEntry(vTimes, Gia_ObjFaninId0p(p, pObj)) );
    Gia_ManForEachRiRo( p, pObjRi, pObjRo, i )
    {
        int TimeNew = Vec_IntEntry(vTimes, Gia_ObjId(p, pObjRi)) - Period;
        TimeNew = Abc_MaxInt( TimeNew, Vec_IntEntry(vTimes, Gia_ObjId(p, pObjRo)) );
        Vec_IntWriteEntry( vTimes, Gia_ObjId(p, pObjRo), TimeNew );
    }
    return fChange;
}

Here is the caller graph for this function:

Gia_ManSifCheckPeriod()

int Gia_ManSifCheckPeriod	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nLutSize,
		int	Period,
		int *	pIters )

Definition at line 491 of file giaSif.c.

{
    Gia_Obj_t * pObj; int i, Id, Stop, nSize = nLutSize+1;
    assert( Gia_ManRegNum(p) > 0 );
    Gia_ManForEachCiId( p, Id, i )
        Vec_IntWriteEntry( vCuts, Id*nSize, 1 );
    Gia_ManForEachCiId( p, Id, i )
        Vec_IntWriteEntry( vCuts, Id*nSize+1, Id << 8 );
    Vec_IntFill( vTimes, Gia_ManObjNum(p), -Period );
    if ( p->vStopsF )
        Vec_StrForEachEntry( p->vStopsF, Stop, i )
            if ( Stop ) Vec_IntWriteEntry( vTimes, i, 0 );
    Vec_IntWriteEntry( vTimes, 0, 0 );
    Gia_ManForEachPi( p, pObj, i )
        Vec_IntWriteEntry( vTimes, Gia_ObjId(p, pObj), 0 );
    for ( *pIters = 0; *pIters < 100; (*pIters)++ )
    {
        if ( !Gia_ManSifCheckIter(p, vCuts, vTimes, nLutSize, Period) )
            return 1;
        Gia_ManForEachPo( p, pObj, i )
            if ( Vec_IntEntry(vTimes, Gia_ObjId(p, pObj)) > Period )
                return 0;
        Gia_ManForEachObj( p, pObj, i )
            if ( Vec_IntEntry(vTimes, Gia_ObjId(p, pObj)) > 2*Period )
                return 0;
        if ( p->vStopsB )
            Vec_StrForEachEntry( p->vStopsB, Stop, i )
                if ( Stop && Vec_IntEntry(vTimes, i) > Period )
                    return 0;              
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDelay()

int Gia_ManSifDelay	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nSize )

Definition at line 338 of file giaSif.c.

{
    Gia_Obj_t * pObj; int i, nFails = 0;
    Gia_ManIncrementTravId( p );
    Gia_ManForEachCo( p, pObj, i )
        nFails += Gia_ManSifDelay_rec( p, Gia_ObjFanin0(pObj), vCuts, vTimes, nSize );
    return nFails;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDelay_rec()

int Gia_ManSifDelay_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nSize )

Definition at line 321 of file giaSif.c.

{
    int i, * pCut, Delay, nFails = 0;
    if ( Gia_ObjUpdateTravIdCurrent(p, pObj) )
        return 0;
    if ( !Gia_ObjIsAnd(pObj) )
        return 0;
    pCut = Vec_IntEntryP( vCuts, Gia_ObjId(p, pObj)*nSize );
    Delay = -ABC_INFINITY-10000;
    for ( i = 1; i <= pCut[0]; i++ )
    {
        nFails += Gia_ManSifDelay_rec( p, Gia_ManObj(p, pCut[i] >> 8), vCuts, vTimes, nSize );
        Delay = Abc_MaxInt( Delay, Vec_IntEntry(vTimes, pCut[i] >> 8) );
    }
    Delay += 1;
    return nFails + (int)(Delay > Vec_IntEntry(vTimes, Gia_ObjId(p, pObj)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDerive()

Gia_Man_t * Gia_ManSifDerive	(	Gia_Man_t *	p,
		Vec_Int_t *	vCounts,
		int	fVerbose )

Definition at line 139 of file giaSif.c.

{
    Gia_Man_t * pNew   = NULL; Gia_Obj_t * pObj;
    Vec_Int_t * vCopy  = Vec_IntStartFull( Gia_ManObjNum(p) );    
    Vec_Int_t * vCopy2 = Vec_IntStartFull( Gia_ManObjNum(p) );    
    Vec_Int_t * vLuts[3], * vRos[3], * vRegs[2], * vInits[2], * vTemp;
    int i, k, Id, iFan;
    for ( i = 0; i < 3; i++ )
    {
        vLuts[i] = Vec_IntAlloc(100);
        vRos[i]  = Vec_IntAlloc(100);
        if ( i == 2 ) break;
        vRegs[i] = Vec_IntAlloc(100);
    }
    Gia_ManForEachLut( p, i )
        if ( Vec_IntEntry(vCounts, i) == 1 )
            Vec_IntPush( vLuts[0], i );
        else if ( Vec_IntEntry(vCounts, i) == -1 )
            Vec_IntPush( vLuts[1], i );
        else if ( Vec_IntEntry(vCounts, i) == 0 )
            Vec_IntPush( vLuts[2], i );
        else assert( 0 );
    assert( Vec_IntSize(vLuts[0]) || Vec_IntSize(vLuts[1]) );
    if ( Vec_IntSize(vLuts[0]) )
    {
        Gia_ManIncrementTravId( p );
        Vec_IntForEachEntry( vLuts[0], Id, i )
            Gia_ObjSetTravIdCurrentId(p, Id);
        Gia_ManForEachRo( p, pObj, i )
            if ( Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin0(Gia_ObjRoToRi(p, pObj))) )
                Vec_IntPush( vRos[0], Gia_ObjId(p, pObj) );
        assert( !Vec_IntSize(vLuts[0]) == !Vec_IntSize(vRos[0]) );
    }
    if ( Vec_IntSize(vLuts[1]) )
    {
        Gia_ManIncrementTravId( p );
        Vec_IntForEachEntry( vLuts[1], Id, i )
            Gia_LutForEachFanin( p, Id, iFan, k )
                Gia_ObjSetTravIdCurrentId(p, iFan);
        Gia_ManForEachRo( p, pObj, i )
            if ( Gia_ObjIsTravIdCurrent(p, pObj) )
                Vec_IntPush( vRos[1], Gia_ObjId(p, pObj) );
        assert( !Vec_IntSize(vLuts[1]) == !Vec_IntSize(vRos[1]) );
    }
    Gia_ManIncrementTravId( p );
    for ( k = 0; k < 2; k++ )
        Vec_IntForEachEntry( vRos[k], Id, i )
            Gia_ObjSetTravIdCurrentId(p, Id);
    Gia_ManForEachRo( p, pObj, i )
        if ( !Gia_ObjIsTravIdCurrent(p, pObj) )
            Vec_IntPush( vRos[2], Gia_ObjId(p, pObj) );
 
    Gia_ManIncrementTravId( p );
    Vec_IntForEachEntry( vLuts[0], Id, i )
        Gia_ObjSetTravIdCurrentId(p, Id);
    Vec_IntForEachEntry( vLuts[0], Id, i )
        Gia_LutForEachFanin( p, Id, iFan, k )
            if ( !Gia_ObjUpdateTravIdCurrentId(p, iFan) )
                Vec_IntPush( vRegs[0], iFan );
    Vec_IntSort( vRegs[0], 0 );
    assert( Vec_IntCountDuplicates(vRegs[1]) == 0 );
    assert( !Vec_IntSize(vLuts[0]) == !Vec_IntSize(vRegs[0]) );
 
    Gia_ManIncrementTravId( p );
    Vec_IntForEachEntry( vLuts[0], Id, i )
        Gia_LutForEachFanin( p, Id, iFan, k )
            Gia_ObjSetTravIdCurrentId(p, iFan);
    Vec_IntForEachEntry( vLuts[2], Id, i )
        Gia_LutForEachFanin( p, Id, iFan, k )
            Gia_ObjSetTravIdCurrentId(p, iFan);
    Gia_ManForEachCo( p, pObj, i )
        Gia_ObjSetTravIdCurrentId(p, Gia_ObjFaninId0p(p, pObj));
    Vec_IntForEachEntry( vRos[1], Id, i )
        if ( Gia_ObjIsTravIdCurrentId(p, Id) )
            Vec_IntPush( vRegs[1], Id );
    Vec_IntForEachEntry( vLuts[1], Id, i )
        if ( Gia_ObjIsTravIdCurrentId(p, Id) )
            Vec_IntPush( vRegs[1], Id );
    Vec_IntSort( vRegs[1], 0 );
    assert( Vec_IntCountDuplicates(vRegs[1]) == 0 );
    assert( !Vec_IntSize(vLuts[1]) == !Vec_IntSize(vRegs[1]) );
 
    vInits[0] = Vec_IntSize(vLuts[0]) ? Gia_ManSifInitPos( p, vLuts[0], vRegs[0] ) : Vec_IntAlloc(0);
    vInits[1] = Vec_IntSize(vLuts[1]) ? Gia_ManSifInitNeg( p, vLuts[1], vRegs[1] ) : Vec_IntAlloc(0);
 
    if ( fVerbose )
    {
        printf( "Flops : %5d %5d %5d\n", Vec_IntSize(vRos[0]),  Vec_IntSize(vRos[1]),  Vec_IntSize(vRos[2]) );
        printf( "LUTs  : %5d %5d %5d\n", Vec_IntSize(vLuts[0]), Vec_IntSize(vLuts[1]), Vec_IntSize(vLuts[2]) );
        printf( "Spots : %5d %5d %5d\n", Vec_IntSize(vRegs[0]), Vec_IntSize(vRegs[1]), 0 );
    }
 
    pNew = Gia_ManStart( Gia_ManObjNum(p) + Vec_IntSize(vRegs[0]) + Vec_IntSize(vRegs[1]) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
 
    Vec_IntWriteEntry( vCopy, 0, 0 );
    Gia_ManForEachPi( p, pObj, i )
        Vec_IntWriteEntry( vCopy, Gia_ObjId(p, pObj), Gia_ManAppendCi(pNew) );
    Vec_IntForEachEntry( vRos[2], Id, i )
        Vec_IntWriteEntry( vCopy, Id, Gia_ManAppendCi(pNew) );
    Vec_IntForEachEntry( vRegs[1], Id, i )
        Vec_IntWriteEntry( vCopy, Id, Abc_LitNotCond(Gia_ManAppendCi(pNew), Vec_IntEntry(vInits[1], i)) );
 
    vTemp = Vec_IntAlloc(100);
    Vec_IntForEachEntry( vRegs[0], Id, i )
        Vec_IntPush( vTemp, Vec_IntEntry(vCopy, Id) );
    Vec_IntForEachEntry( vRegs[0], Id, i )
        Vec_IntWriteEntry( vCopy, Id, Abc_LitNotCond(Gia_ManAppendCi(pNew), Vec_IntEntry(vInits[0], i)) );
    Vec_IntForEachEntry( vLuts[0], Id, i )
        Gia_ManSifDupNode( pNew, p, Id, vCopy );
    Vec_IntForEachEntry( vRegs[0], Id, i )
        Vec_IntWriteEntry( vCopy, Id, Vec_IntEntry(vTemp, i) );
    Vec_IntFree( vTemp );
 
    Gia_ManForEachRoToRiVec( vRos[0], p, pObj, i )
        Vec_IntWriteEntry( vCopy, Vec_IntEntry(vRos[0], i), Abc_LitNotCond(Vec_IntEntry(vCopy, Gia_ObjFaninId0p(p, pObj)), Gia_ObjFaninC0(pObj)) );
    Vec_IntForEachEntry( vLuts[2], Id, i )
        Gia_ManSifDupNode( pNew, p, Id, vCopy );
 
    Gia_ManForEachRoToRiVec( vRos[1], p, pObj, i )
        Vec_IntWriteEntry( vCopy2, Vec_IntEntry(vRos[1], i), Abc_LitNotCond(Vec_IntEntry(vCopy, Gia_ObjFaninId0p(p, pObj)), Gia_ObjFaninC0(pObj)) );
    Vec_IntForEachEntry( vLuts[1], Id, i )
        Gia_ManSifDupNode( pNew, p, Id, vCopy2 );
 
    Gia_ManForEachPo( p, pObj, i )
        Gia_ManAppendCo( pNew, Abc_LitNotCond(Vec_IntEntry(vCopy, Gia_ObjFaninId0p(p, pObj)), Gia_ObjFaninC0(pObj)) );
    Gia_ManForEachRoToRiVec( vRos[2], p, pObj, i )
        Gia_ManAppendCo( pNew, Abc_LitNotCond(Vec_IntEntry(vCopy, Gia_ObjFaninId0p(p, pObj)), Gia_ObjFaninC0(pObj)) );
    Vec_IntForEachEntry( vRegs[1], Id, i )
        Gia_ManAppendCo( pNew, Abc_LitNotCond(Vec_IntEntry(vCopy2, Id), Vec_IntEntry(vInits[1], i)) );
    Vec_IntForEachEntry( vRegs[0], Id, i )
        Gia_ManAppendCo( pNew, Abc_LitNotCond(Vec_IntEntry(vCopy, Id), Vec_IntEntry(vInits[0], i)) );
 
    Gia_ManSetRegNum( pNew, Vec_IntSize(vRos[2]) + Vec_IntSize(vRegs[0]) + Vec_IntSize(vRegs[1]) );
 
    for ( i = 0; i < 3; i++ )
    {
        Vec_IntFreeP( &vLuts[i] );
        Vec_IntFreeP( &vRos[i] );
        if ( i == 2 ) break;
        Vec_IntFreeP( &vRegs[i] );
        Vec_IntFreeP( &vInits[i] );
    }
    Vec_IntFree( vCopy );
    Vec_IntFree( vCopy2 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDeriveMapping()

int Gia_ManSifDeriveMapping	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nLutSize,
		int	Period,
		int	fVerbose )

Definition at line 580 of file giaSif.c.

{
    Gia_Obj_t * pObj; int i, nArea = 0;
    if ( p->vMapping != NULL )
    {
        printf( "Removing available combinational mapping.\n" );
        Vec_IntFreeP( &p->vMapping );
    }
    assert( p->vMapping == NULL );
    p->vMapping = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_ManIncrementTravId( p );
    Gia_ManForEachCo( p, pObj, i )
        nArea += Gia_ManSifDeriveMapping_rec( p, Gia_ObjFanin0(pObj), vCuts, nLutSize+1 );
    return nArea;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDeriveMapping_rec()

int Gia_ManSifDeriveMapping_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vCuts,
		int	nSize )

Definition at line 559 of file giaSif.c.

{
    int i, * pCut, Area = 1;
    if ( !Gia_ObjIsAnd(pObj) )
        return 0;
    if ( Gia_ObjUpdateTravIdCurrent(p, pObj) )
        return 0;
    pCut = Vec_IntEntryP( vCuts, Gia_ObjId(p, pObj)*nSize );
    for ( i = 1; i <= pCut[0]; i++ )
        Area += Gia_ManSifDeriveMapping_rec( p, Gia_ManObj(p, pCut[i] >> 8), vCuts, nSize );
    Vec_IntWriteEntry( p->vMapping, Gia_ObjId(p, pObj), Vec_IntSize(p->vMapping) );
    Vec_IntPush( p->vMapping, pCut[0] );
    for ( i = 1; i <= pCut[0]; i++ )
    {
        Gia_Obj_t * pObj = Gia_ManObj(p, pCut[i] >> 8);
        assert( !Gia_ObjIsAnd(pObj) || Gia_ObjIsLut(p, pCut[i] >> 8) );
        Vec_IntPush( p->vMapping, pCut[i] >> 8 );
    }
    Vec_IntPush( p->vMapping, -1 );
    return Area;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDupNode()

void Gia_ManSifDupNode	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vCopy )

Definition at line 53 of file giaSif.c.

{
    int k, iFan;
    Gia_Obj_t * pObj = Gia_ManObj(p, iObj); 
    Gia_ManIncrementTravId( p );
    Gia_LutForEachFanin( p, iObj, iFan, k )
    {
        assert( Vec_IntEntry(vCopy, iFan) >= 0 );
        Gia_ManObj(p, iFan)->Value = Vec_IntEntry(vCopy, iFan);
        Gia_ObjUpdateTravIdCurrentId(p, iFan);
    }
    Gia_ManSifDupNode_rec( pNew, p, pObj );
    Vec_IntWriteEntry( vCopy, iObj, pObj->Value );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifDupNode_rec()

ABC_NAMESPACE_IMPL_START void Gia_ManSifDupNode_rec	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

DECLARATIONS ///.

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

FileName [giaSif.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Sequential mapping.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file giaSif.c.

{
    if ( Gia_ObjUpdateTravIdCurrent(p, pObj) )
        return;
    assert( Gia_ObjIsAnd(pObj) );
    Gia_ManSifDupNode_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManSifDupNode_rec( pNew, p, Gia_ObjFanin1(pObj) );
    pObj->Value = Gia_ManAppendAnd2( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
} 

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifInitNeg()

Vec_Int_t * Gia_ManSifInitNeg	(	Gia_Man_t *	p,
		Vec_Int_t *	vMoves,
		Vec_Int_t *	vRegs )

Definition at line 67 of file giaSif.c.

{
    Vec_Int_t * vRes = Vec_IntAlloc( Vec_IntSize(vRegs) );
    Gia_Obj_t * pObj; int i, iObj;
    Gia_Man_t * pNew = Gia_ManStart( 1000 ), * pTemp;
    Vec_Int_t * vCopy = Vec_IntStartFull( Gia_ManObjNum(p) );
    Vec_IntWriteEntry( vCopy, 0, 0 );
    Gia_ManForEachRo( p, pObj, i )
        Vec_IntWriteEntry( vCopy, Gia_ObjId(p, pObj), Gia_ManAppendCi(pNew) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Vec_IntForEachEntry( vMoves, iObj, i )
        Gia_ManSifDupNode( pNew, p, iObj, vCopy );
    Vec_IntForEachEntry( vRegs, iObj, i )
    {
        int iLit = Vec_IntEntry( vCopy, iObj );
        assert( iLit >= 0 );
        Gia_ManAppendCo( pNew, iLit );
    }
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Gia_ManSetPhase( pNew );
    Gia_ManForEachPo( pNew, pObj, i )
        Vec_IntPush( vRes, pObj->fPhase );
    Gia_ManStop( pNew );
    Vec_IntFree( vCopy );
    assert( Vec_IntSize(vRes) == Vec_IntSize(vRegs) );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifInitPos()

Vec_Int_t * Gia_ManSifInitPos	(	Gia_Man_t *	p,
		Vec_Int_t *	vMoves,
		Vec_Int_t *	vRegs )

Definition at line 96 of file giaSif.c.

{
    extern int * Abc_NtkSolveGiaMiter( Gia_Man_t * p );
    int i, iObj, iLitAnd = 1, * pResult = NULL;
    Gia_Obj_t * pObj; Vec_Int_t * vRes = NULL;
    Gia_Man_t * pNew = Gia_ManStart( 1000 ), * pTemp;
    Vec_Int_t * vCopy = Vec_IntStartFull( Gia_ManObjNum(p) );
    Vec_IntWriteEntry( vCopy, 0, 0 );
    Vec_IntForEachEntry( vRegs, iObj, i )
        Vec_IntWriteEntry( vCopy, iObj, Gia_ManAppendCi(pNew) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Vec_IntForEachEntry( vMoves, iObj, i )
        Gia_ManSifDupNode( pNew, p, iObj, vCopy );
    Gia_ManForEachRi( p, pObj, i )
    {
        int iFan = Gia_ObjFaninId0p(p, pObj);
        int iLit = Vec_IntEntry(vCopy, iFan);
        if ( iLit == -1 )
            continue;
        iLit = Abc_LitNotCond( iLit, Gia_ObjFaninC0(pObj) );
        iLitAnd = Gia_ManAppendAnd2( pNew, iLitAnd, Abc_LitNot(iLit) );
    }
    Gia_ManAppendCo( pNew, iLitAnd );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    pResult = Abc_NtkSolveGiaMiter( pNew );
    if ( pResult )
    {
        vRes = Vec_IntAllocArray( pResult, Vec_IntSize(vRegs) );
        Gia_ManSetPhasePattern( pNew, vRes );
        assert( Gia_ManPo(pNew, 0)->fPhase == 1 );
    }
    else
    {
        vRes = Vec_IntStart( Vec_IntSize(vRegs) );
        printf( "***!!!*** The SAT problem has no solution. Using all-0 initial state. ***!!!***\n" );
    }
    Gia_ManStop( pNew );
    Vec_IntFree( vCopy );
    assert( Vec_IntSize(vRes) == Vec_IntSize(vRegs) );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSifMapComb()

int Gia_ManSifMapComb	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nLutSize )

Definition at line 523 of file giaSif.c.

{
    Gia_Obj_t * pObj; int i, Id, Res = 0, nSize = nLutSize+1; 
    Vec_IntFill( vTimes, Gia_ManObjNum(p), 0 );
    Gia_ManForEachCiId( p, Id, i )
        Vec_IntWriteEntry( vCuts, Id*nSize, 1 );
    Gia_ManForEachCiId( p, Id, i )
        Vec_IntWriteEntry( vCuts, Id*nSize+1, Id << 8 );
    Gia_ManForEachAnd( p, pObj, i )
        Gia_ManSifCutOne( p, i, vCuts, vTimes, nSize );
    Gia_ManForEachCo( p, pObj, i )
        Res = Abc_MaxInt( Res, Vec_IntEntry(vTimes, Gia_ObjFaninId0p(p, pObj)) );
    return Res;
}

Here is the caller graph for this function:

Gia_ManSifPerform()

Gia_Man_t * Gia_ManSifPerform	(	Gia_Man_t *	p,
		int	nLutSize,
		int	fEvalOnly,
		int	fVerbose )

Definition at line 595 of file giaSif.c.

{
    Gia_Man_t * pNew = NULL;
    int nIters, Status, nSize = nLutSize+1; // (2+1+nSize)*4=40 bytes/node
    abctime clk = Abc_Clock(); 
    Vec_Int_t * vCuts  = Vec_IntStart( Gia_ManObjNum(p) * nSize );
    Vec_Int_t * vTimes = Vec_IntAlloc( Gia_ManObjNum(p) );
    int Lower = 0;
    int Upper = Gia_ManSifMapComb( p, vCuts, vTimes, nLutSize );
    int CombD = Upper;
    if ( fVerbose && Gia_ManRegNum(p) )
    printf( "Clock period %2d is %s\n", Lower, 0 ? "Yes" : "No " );
    if ( fVerbose && Gia_ManRegNum(p) )
    printf( "Clock period %2d is %s\n", Upper, 1 ? "Yes" : "No " );
    while ( Gia_ManRegNum(p) > 0 && Upper - Lower > 1 )
    {
        int Middle = (Upper + Lower) / 2;
        int Status = Gia_ManSifCheckPeriod( p, vCuts, vTimes, nLutSize, Middle, &nIters );
        if ( Status )
            Upper = Middle;
        else
            Lower = Middle;
        if ( fVerbose )
        printf( "Clock period %2d is %s after %d iterations\n", Middle, Status ? "Yes" : "No ", nIters );
    }
    if ( fVerbose )
    printf( "Best  period = <<%d>> (%.2f %%)  ", Upper, (float)(100.0*(CombD-Upper)/CombD) );
    if ( fVerbose )
    printf( "LUT size = %d   ", nLutSize );
    if ( fVerbose )
    printf( "Memory usage = %.2f MB   ", 4.0*(2+1+nSize)*Gia_ManObjNum(p)/(1 << 20) );
    if ( fVerbose )
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    if ( Upper == CombD )
    {
        Vec_IntFree( vCuts );
        Vec_IntFree( vTimes );
        printf( "Combinational delay (%d) cannot be improved.\n", CombD );
        return Gia_ManDup( p );
    }
    Status = Gia_ManSifCheckPeriod( p, vCuts, vTimes, nLutSize, Upper, &nIters );
    assert( Status );
    Status = Gia_ManSifDeriveMapping( p, vCuts, vTimes, nLutSize, Upper, fVerbose );
    if ( fEvalOnly )
    {
        printf( "Optimized level %2d  (%6.2f %% less than comb level %2d).  LUT size = %d.  Area estimate = %d.\n", 
            Upper, (float)(100.0*(CombD-Upper)/CombD), CombD, nLutSize, Gia_ManSifArea(p, vCuts, nLutSize+1) );     
        printf( "The command is invoked in the evaluation mode. Retiming is not performed.\n" );
    }
    else
        pNew = Gia_ManSifTransform( p, vCuts, vTimes, nLutSize, Upper, fVerbose );
    Vec_IntFree( vCuts );
    Vec_IntFree( vTimes );
    //Gia_ManTransferTiming( pNew, p );
    if ( p->vNamesIn ) {
        char * pName; int i;
        pNew->vNamesIn     = p->vNamesIn;     p->vNamesIn     = NULL;
        Vec_PtrForEachEntryStart( char *, pNew->vNamesIn, pName, i, Gia_ManPiNum(pNew) )
            ABC_FREE( pName );
        Vec_PtrShrink( pNew->vNamesIn, Gia_ManPiNum(pNew) );
        for ( i = 0; i < Gia_ManRegNum(pNew); i++ )
            Vec_PtrPush( pNew->vNamesIn, Abc_UtilStrsavNum("_fo", i) );
    }
    if ( p->vNamesOut ) {
        char * pName; int i;
        pNew->vNamesOut    = p->vNamesOut;    p->vNamesOut    = NULL;
        Vec_PtrForEachEntryStart( char *, pNew->vNamesOut, pName, i, Gia_ManPoNum(pNew) )
            ABC_FREE( pName );
        Vec_PtrShrink( pNew->vNamesOut, Gia_ManPoNum(pNew) );
        for ( i = 0; i < Gia_ManRegNum(pNew); i++ )
            Vec_PtrPush( pNew->vNamesOut, Abc_UtilStrsavNum("_fi", i) );
    }
    return pNew;
}

Here is the call graph for this function:

Gia_ManSifPrintTimes()

void Gia_ManSifPrintTimes	(	Gia_Man_t *	p,
		Vec_Int_t *	vTimes,
		int	Period )

Definition at line 537 of file giaSif.c.

{
    int i, Value, Pos[256] = {0}, Neg[256] = {0};
    Gia_ManForEachLut( p, i )
    {        
        Value = Gia_ManSifTimeToCount( Vec_IntEntry(vTimes, i), Period );
        Value = Abc_MinInt( Value,  255 );
        Value = Abc_MaxInt( Value, -255 );
        if ( Value >= 0 )
            Pos[Value]++;
        else
            Neg[-Value]++;
    }
    printf( "Statistics: " );
    for ( i = 255; i > 0; i-- )
        if ( Neg[i] )
            printf( " -%d=%d", i, Neg[i] );
    for ( i = 0; i < 256; i++ )
        if ( Pos[i] )
            printf( " %d=%d", i, Pos[i] );
    printf( "\n" );
}

Gia_ManSifTimesToCounts()

Vec_Int_t * Gia_ManSifTimesToCounts	(	Gia_Man_t *	p,
		Vec_Int_t *	vTimes,
		int	Period )

Definition at line 350 of file giaSif.c.

{
    int i, Times;
    Vec_Int_t * vCounts = Vec_IntStart( Gia_ManObjNum(p) ); 
    Vec_IntFillExtra( vTimes, Gia_ManObjNum(p), 0 );
    Vec_IntForEachEntry( vTimes, Times, i )
        if ( Gia_ObjIsLut(p, i) )
            Vec_IntWriteEntry( vCounts, i, Gia_ManSifTimeToCount(Times, Period) );
    return vCounts;
}

Here is the caller graph for this function:

Gia_ManSifTransform()

Gia_Man_t * Gia_ManSifTransform	(	Gia_Man_t *	p,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vTimes,
		int	nLutSize,
		int	Period,
		int	fVerbose )

Definition at line 360 of file giaSif.c.

{
    Gia_Man_t * pNew = NULL; Vec_Int_t * vCounts = NULL;
    if ( fVerbose )
        printf( "Current area = %d.  Period = %d.  ", Gia_ManSifArea(p, vCuts, nLutSize+1), Period );
    if ( fVerbose )
        printf( "Delay checking failed for %d cuts.\n", Gia_ManSifDelay( p, vCuts, vTimes, nLutSize+1 ) );
    vCounts   = Gia_ManSifTimesToCounts( p, vTimes, Period );
    pNew      = Gia_ManSifDerive( p, vCounts, fVerbose );
    Vec_IntFreeP( &vCounts );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function: