giaResub2.c File Reference

#include "gia.h"
#include "misc/util/utilTruth.h"
#include "misc/vec/vecHsh.h"
#include "opt/dau/dau.h"

Include dependency graph for giaResub2.c:

Go to the source code of this file.

Classes
struct	Gia_Rsb2Man_t_

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Gia_Rsb2Man_t_	Gia_Rsb2Man_t
	DECLARATIONS ///.

Functions
void	Abc_ResubPrepareManager (int nWords)
int	Abc_ResubComputeFunction (void **ppDivs, int nDivs, int nWords, int nLimit, int nDivsMax, int iChoice, int fUseXor, int fDebug, int fVerbose, int **ppArray)
Gia_Rsb2Man_t *	Gia_Rsb2ManAlloc ()
	FUNCTION DEFINITIONS ///.
void	Gia_Rsb2ManFree (Gia_Rsb2Man_t *p)
void	Gia_Rsb2ManStart (Gia_Rsb2Man_t *p, int *pObjs, int nObjs, int nDivsMax, int nLevelIncrease, int fUseXor, int fUseZeroCost, int fDebug, int fVerbose)
void	Gia_Rsb2ManPrint (Gia_Rsb2Man_t *p)
int	Gia_Rsb2ManLevel (Gia_Rsb2Man_t *p)
word	Gia_Rsb2ManOdcs (Gia_Rsb2Man_t *p, int iNode)
int	Gia_Rsb2ManDeref_rec (Gia_Rsb2Man_t *p, int *pObjs, int *pRefs, int iNode)
int	Gia_Rsb2ManMffc (Gia_Rsb2Man_t *p, int iNode)
int	Gia_Rsb2ManDivs (Gia_Rsb2Man_t *p, int iNode)
int	Gia_Rsb2AddNode (Vec_Int_t *vRes, int iLit0, int iLit1, int iRes0, int iRes1)
int	Gia_Rsb2ManInsert_rec (Vec_Int_t *vRes, int nPis, Vec_Int_t *vObjs, int iNode, Vec_Int_t *vResub, Vec_Int_t *vDivs, Vec_Int_t *vCopies, int iObj)
Vec_Int_t *	Gia_Rsb2ManInsert (int nPis, int nPos, Vec_Int_t *vObjs, int iNode, Vec_Int_t *vResub, Vec_Int_t *vDivs, Vec_Int_t *vCopies)
void	Abc_ResubPrintDivs (void **ppDivs, int nDivs)
int	Abc_ResubNodeToTry (Vec_Int_t *vTried, int iFirst, int iLast)
int	Abc_ResubComputeWindow (int *pObjs, int nObjs, int nDivsMax, int nLevelIncrease, int fUseXor, int fUseZeroCost, int fDebug, int fVerbose, int **ppArray, int *pnResubs)
int	Abc_ResubComputeWindow2 (int *pObjs, int nObjs, int nDivsMax, int nLevelIncrease, int fUseXor, int fUseZeroCost, int fDebug, int fVerbose, int **ppArray, int *pnResubs)
int *	Gia_ManToResub (Gia_Man_t *p)
Gia_Man_t *	Gia_ManFromResub (int *pObjs, int nObjs, int nIns)
Gia_Man_t *	Gia_ManResub2Test (Gia_Man_t *p)
int	Gia_WinTryAddingNode (Gia_Man_t *p, int iPivot, int iPivot2, Vec_Wec_t *vLevels, Vec_Int_t *vNodes)
int	Gia_WinAddCiWithMaxFanouts (Gia_Man_t *p)
int	Gia_WinAddCiWithMaxDivisors (Gia_Man_t *p, Vec_Wec_t *vLevels)
int	Gia_WinNodeHasUnmarkedFanouts (Gia_Man_t *p, int iPivot)
Vec_Int_t *	Gia_RsbCiTranslate (Gia_Man_t *p, Vec_Int_t *vObjs, Vec_Int_t *vMap)
Vec_Int_t *	Gia_RsbCiWindow (Gia_Man_t *p, int nPis)
void	Gia_RsbCiWindowTest (Gia_Man_t *p)
void	Gia_RsbWindowGather (Gia_Man_t *p, Vec_Int_t *vPaths, int iNode, Vec_Int_t *vVisited)
int	Gia_RsbWindowExplore (Gia_Man_t *p, Vec_Int_t *vVisited, int iStart, Vec_Int_t *vPaths, int *piMeet, int *piNode)
Vec_Int_t *	Gia_RsbWindowInit (Gia_Man_t *p, Vec_Int_t *vPaths, int iPivot, int nIter)
Vec_Int_t *	Gia_RsbCreateWindowInputs (Gia_Man_t *p, Vec_Int_t *vWin)
void	Gia_RsbAddSideInputs (Gia_Man_t *p, Vec_Wec_t *vLevels, Vec_Int_t *vWin)
void	Gia_RsbExpandInputs (Gia_Man_t *p, Vec_Wec_t *vLevels, Vec_Int_t *vWin, Vec_Int_t *vInputs)
int	Gia_RsbSelectOneInput (Gia_Man_t *p, Vec_Wec_t *vLevels, Vec_Int_t *vIns)
void	Gia_RsbWindowGrow (Gia_Man_t *p, Vec_Wec_t *vLevels, Vec_Int_t *vWin, Vec_Int_t *vIns, int nInputsMax)
void	Gia_WinCreateFromCut_rec (Gia_Man_t *p, int iObj, Vec_Int_t *vWin)
void	Gia_WinCreateFromCut (Gia_Man_t *p, int iPivot, Vec_Int_t *vIn, Vec_Wec_t *vLevels, Vec_Int_t *vWin)
int	Gia_RsbExpandCut (Gia_Man_t *p, Vec_Int_t *vIns)
int	Gia_RsbFindFaninAdd (int iFan, int pFanins[32], int pFaninCounts[32], int nFanins)
int	Gia_RsbFindFaninToAddToCut (Gia_Man_t *p, Vec_Int_t *vIns)
void	Gia_RsbWindowGrow2 (Gia_Man_t *p, int iObj, Vec_Wec_t *vLevels, Vec_Int_t *vWin, Vec_Int_t *vIns, int nInputsMax)
int	Gia_RsbWindowCompute (Gia_Man_t *p, int iObj, int nInputsMax, int nLevelsMax, Vec_Wec_t *vLevels, Vec_Int_t *vPaths, Vec_Int_t **pvWin, Vec_Int_t **pvIns)
Vec_Int_t *	Gia_RsbFindOutputs (Gia_Man_t *p, Vec_Int_t *vWin, Vec_Int_t *vIns, Vec_Int_t *vRefs)
Gia_Man_t *	Gia_RsbDeriveGiaFromWindows (Gia_Man_t *p, Vec_Int_t *vWin, Vec_Int_t *vIns, Vec_Int_t *vOuts)
word	Gia_LutComputeTruth66_rec (Gia_Man_t *p, Gia_Obj_t *pObj)
int	Gia_ManVerifyTwoTruths (Gia_Man_t *p1, Gia_Man_t *p2)
void	Gia_RsbEnumerateWindows (Gia_Man_t *p, int nInputsMax, int nLevelsMax)
Gia_Man_t *	Gia_RsbTryOneWindow (Gia_Man_t *p)
void	Gia_RsbTestArray ()
Vec_Wec_t *	Gia_ManExtractCuts2 (Gia_Man_t *p, int nCutSize, int nCuts, int fVerbose)

Typedef Documentation

Gia_Rsb2Man_t

typedef typedefABC_NAMESPACE_IMPL_START struct Gia_Rsb2Man_t_ Gia_Rsb2Man_t

DECLARATIONS ///.

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

FileName [giaResub2.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis []

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 33 of file giaResub2.c.

Function Documentation

Abc_ResubComputeFunction()

int Abc_ResubComputeFunction ( void ** ppDivs, int nDivs, int nWords, int nLimit, int nDivsMax, int iChoice, int fUseXor, int fDebug, int fVerbose, int ** ppArray )

extern

Definition at line 1548 of file giaResub.c.

{
    Vec_Ptr_t Divs = { nDivs, nDivs, ppDivs };
    assert( s_pResbMan != NULL ); // first call Abc_ResubPrepareManager()
    Gia_ManResubPerform( s_pResbMan, &Divs, nWords, nLimit, nDivsMax, iChoice, fUseXor, fDebug, fVerbose==2, 0 );
    if ( fVerbose )
    {
        int nGates = Vec_IntSize(s_pResbMan->vGates)/2;
        if ( nGates )
        {
            printf( "      Gain = %2d  Gates = %2d  __________  F = ", nLimit+1-nGates, nGates );
            Gia_ManResubPrint( s_pResbMan->vGates, nDivs );
            printf( "\n" );
        }
    }
    if ( fDebug )
    {
        if ( !Gia_ManResubVerify(s_pResbMan, NULL) )
        {
            Gia_ManResubPrint( s_pResbMan->vGates, nDivs );
            printf( "Verification FAILED.\n" );
        }
        //else
        //    printf( "Verification succeeded.\n" );
    }
    *ppArray = Vec_IntArray(s_pResbMan->vGates);
    assert( Vec_IntSize(s_pResbMan->vGates)/2 <= nLimit );
    return Vec_IntSize(s_pResbMan->vGates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ResubComputeWindow()

int Abc_ResubComputeWindow	(	int *	pObjs,
		int	nObjs,
		int	nDivsMax,
		int	nLevelIncrease,
		int	fUseXor,
		int	fUseZeroCost,
		int	fDebug,
		int	fVerbose,
		int **	ppArray,
		int *	pnResubs )

Definition at line 434 of file giaResub2.c.

{
    int iNode, nChanges = 0, RetValue = 0;
    Gia_Rsb2Man_t * p = Gia_Rsb2ManAlloc(); 
    Gia_Rsb2ManStart( p, pObjs, nObjs, nDivsMax, nLevelIncrease, fUseXor, fUseZeroCost, fDebug, fVerbose );
    *ppArray = NULL;
    while ( (iNode = Abc_ResubNodeToTry(&p->vTried, p->nPis+1, p->iFirstPo)) > 0 )
    {
        int nDivs = Gia_Rsb2ManDivs( p, iNode );
        int * pResub, nResub = Abc_ResubComputeFunction( Vec_PtrArray(&p->vpDivs), nDivs, 1, p->nMffc-1, nDivsMax, 0, fUseXor, fDebug, fVerbose, &pResub );
        if ( nResub == 0 )
            Vec_IntPush( &p->vTried, iNode );
        else
        {
            int i, k = 0, iTried;
            Vec_Int_t vResub = { nResub, nResub, pResub };
            Vec_Int_t * vRes = Gia_Rsb2ManInsert( p->nPis, p->nPos, &p->vObjs, iNode, &vResub, &p->vDivs, &p->vCopies );
            //printf( "\nResubing node %d:\n", iNode );
            //Gia_Rsb2ManPrint( p );
            p->nObjs    = Vec_IntSize(vRes)/2;
            p->iFirstPo = p->nObjs - p->nPos;
            Vec_IntClear( &p->vObjs );
            Vec_IntAppend( &p->vObjs, vRes );
            Vec_IntFree( vRes );
            Vec_IntForEachEntry( &p->vTried, iTried, i )
                if ( Vec_IntEntry(&p->vCopies, iTried) > Abc_Var2Lit(p->nPis, 0) ) // internal node
                    Vec_IntWriteEntry( &p->vTried, k++, Abc_Lit2Var(Vec_IntEntry(&p->vCopies, iTried)) );
            Vec_IntShrink( &p->vTried, k );
            nChanges++;
            //Gia_Rsb2ManPrint( p );
        }
    }
    if ( nChanges )
    {
        RetValue = p->nObjs;
        *ppArray = p->vObjs.pArray;
        Vec_IntZero( &p->vObjs );
    }
    Gia_Rsb2ManFree( p );
    if ( pnResubs )
        *pnResubs = nChanges;
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ResubComputeWindow2()

int Abc_ResubComputeWindow2	(	int *	pObjs,
		int	nObjs,
		int	nDivsMax,
		int	nLevelIncrease,
		int	fUseXor,
		int	fUseZeroCost,
		int	fDebug,
		int	fVerbose,
		int **	ppArray,
		int *	pnResubs )

Definition at line 477 of file giaResub2.c.

{
    *ppArray = ABC_ALLOC( int, 2*nObjs );
    memmove( *ppArray, pObjs, 2*nObjs * sizeof(int) );
    if ( pnResubs )
        *pnResubs = 0;
    return nObjs;
}

Here is the call graph for this function:

Abc_ResubNodeToTry()

int Abc_ResubNodeToTry	(	Vec_Int_t *	vTried,
		int	iFirst,
		int	iLast )

Definition at line 425 of file giaResub2.c.

{
    int iNode;
    //for ( iNode = iFirst; iNode < iLast; iNode++ )
    for ( iNode = iLast - 1; iNode >= iFirst; iNode-- )
        if ( Vec_IntFind(vTried, iNode) == -1 )
            return iNode;
    return -1;
}

Here is the caller graph for this function:

Abc_ResubPrepareManager()

void Abc_ResubPrepareManager ( int nWords )

extern

Definition at line 1539 of file giaResub.c.

{
    if ( s_pResbMan != NULL )
        Gia_ResbFree( s_pResbMan );
    s_pResbMan = NULL;
    if ( nWords > 0 )
        s_pResbMan = Gia_ResbAlloc( nWords );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ResubPrintDivs()

void Abc_ResubPrintDivs	(	void **	ppDivs,
		int	nDivs )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 415 of file giaResub2.c.

{
    word ** pDivs = (word **)ppDivs;
    int i;
    for ( i = 0; i < nDivs; i++ )
    {
        printf( "Div %2d : ", i );
        Dau_DsdPrintFromTruth( pDivs[i], 6 );
    }
}

Here is the call graph for this function:

Gia_LutComputeTruth66_rec()

word Gia_LutComputeTruth66_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

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

Synopsis [Naive truth-table-based verification.]

Description []

SideEffects []

SeeAlso []

Definition at line 1297 of file giaResub2.c.

{
    word Truth0, Truth1;
    if ( Gia_ObjIsCi(pObj) )
        return s_Truths6[Gia_ObjCioId(pObj)];
    if ( Gia_ObjIsConst0(pObj) )
        return 0;
    assert( Gia_ObjIsAnd(pObj) );
    Truth0 = Gia_LutComputeTruth66_rec( p, Gia_ObjFanin0(pObj) );
    Truth1 = Gia_LutComputeTruth66_rec( p, Gia_ObjFanin1(pObj) );
    if ( Gia_ObjFaninC0(pObj) )
        Truth0 = ~Truth0;
    if ( Gia_ObjFaninC1(pObj) )
        Truth1 = ~Truth1;
    return Truth0 & Truth1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManExtractCuts2()

Vec_Wec_t * Gia_ManExtractCuts2	(	Gia_Man_t *	p,
		int	nCutSize,
		int	nCuts,
		int	fVerbose )

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

Synopsis [Computing cuts of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1523 of file giaResub2.c.

{
    int c, nLevelMax = 8;
    abctime clk = Abc_Clock();
    Vec_Wec_t * vCuts = Vec_WecStart( nCuts );
    Vec_Int_t * vPaths = Vec_IntStart( Gia_ManObjNum(p) );
    srand( time(NULL) );
    for ( c = 0; c < nCuts; )
    {
        Vec_Int_t * vCut, * vWin = NULL;
        while ( vWin == NULL )
        {
            int iPivot = 1 + Gia_ManCiNum(p) + rand() % Gia_ManAndNum(p);
            assert( Gia_ObjIsAnd(Gia_ManObj(p, iPivot)) );
            vWin = Gia_RsbWindowInit( p, vPaths, iPivot, nLevelMax );
        }
        vCut = Gia_RsbCreateWindowInputs( p, vWin );
        if ( Vec_IntSize(vCut) >= nCutSize - 2 && Vec_IntSize(vCut) <= nCutSize )
        {
            Vec_IntPush( Vec_WecEntry(vCuts, c), Vec_IntSize(vCut) );
            Vec_IntAppend( Vec_WecEntry(vCuts, c++), vCut );
        }
        Vec_IntFree( vCut );
        Vec_IntFree( vWin );
    }
    Vec_IntFree( vPaths );
    Abc_PrintTime( 0, "Computing cuts  ", Abc_Clock() - clk );
    return vCuts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManFromResub()

Gia_Man_t * Gia_ManFromResub	(	int *	pObjs,
		int	nObjs,
		int	nIns )

Definition at line 515 of file giaResub2.c.

{
    Gia_Man_t * pNew = Gia_ManStart( nObjs );
    int i;
    for ( i = 1; i < nObjs; i++ )
    {
        if ( pObjs[2*i] == 0 && i <= nIns ) // pi
            Gia_ManAppendCi( pNew );
        else if ( pObjs[2*i] == pObjs[2*i+1] ) // po
            Gia_ManAppendCo( pNew, pObjs[2*i] );
        else if ( pObjs[2*i] < pObjs[2*i+1] )
            Gia_ManAppendAnd( pNew, pObjs[2*i], pObjs[2*i+1] );
        else if ( pObjs[2*i] > pObjs[2*i+1] )
            Gia_ManAppendXor( pNew, pObjs[2*i], pObjs[2*i+1] );
        else assert( 0 );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManResub2Test()

Gia_Man_t * Gia_ManResub2Test

(

Gia_Man_t *

p

)

Definition at line 533 of file giaResub2.c.

{
    Gia_Man_t * pNew;
    int nResubs, nObjsNew, * pObjsNew, * pObjs = Gia_ManToResub( p );
//Gia_ManPrint( p );
    Abc_ResubPrepareManager( 1 );
    nObjsNew = Abc_ResubComputeWindow( pObjs, Gia_ManObjNum(p), 1000, -1, 0, 0, 0, 0, &pObjsNew, &nResubs );
    //printf( "Performed resub %d times.  Reduced %d nodes.\n", nResubs, nObjsNew ? Gia_ManObjNum(p) - nObjsNew : 0 );
    Abc_ResubPrepareManager( 0 );
    if ( nObjsNew )
    {
        pNew = Gia_ManFromResub( pObjsNew, nObjsNew, Gia_ManCiNum(p) );
        pNew->pName = Abc_UtilStrsav( p->pName );
    }
    else 
        pNew = Gia_ManDup( p );
    ABC_FREE( pObjs );
    ABC_FREE( pObjsNew );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManToResub()

int * Gia_ManToResub

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 497 of file giaResub2.c.

{
    Gia_Obj_t * pObj;
    int i, * pObjs = ABC_CALLOC( int, 2*Gia_ManObjNum(p) );
    assert( Gia_ManIsNormalized(p) );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            continue;
        pObjs[2*i+0] = Gia_ObjFaninLit0(Gia_ManObj(p, i), i);
        if ( Gia_ObjIsCo(pObj) )
            pObjs[2*i+1] = pObjs[2*i+0];
        else if ( Gia_ObjIsAnd(pObj) )
            pObjs[2*i+1] = Gia_ObjFaninLit1(Gia_ManObj(p, i), i);
        else assert( 0 );
    }
    return pObjs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManVerifyTwoTruths()

int Gia_ManVerifyTwoTruths	(	Gia_Man_t *	p1,
		Gia_Man_t *	p2 )

Definition at line 1313 of file giaResub2.c.

{
    int i, fFailed = 0;
    assert( Gia_ManCoNum(p1) == Gia_ManCoNum(p2) );
    for ( i = 0; i < Gia_ManCoNum(p1); i++ )
    {
        Gia_Obj_t * pPo1 = Gia_ManCo(p1, i);
        Gia_Obj_t * pPo2 = Gia_ManCo(p2, i);
        word word1 = Gia_LutComputeTruth66_rec( p1, Gia_ObjFanin0(pPo1) );
        word word2 = Gia_LutComputeTruth66_rec( p2, Gia_ObjFanin0(pPo2) );
        if ( Gia_ObjFaninC0(pPo1) )
            word1 = ~word1;
        if ( Gia_ObjFaninC0(pPo2) )
            word2 = ~word2;
        if ( word1 != word2 )
        {
            //Dau_DsdPrintFromTruth( &word1, 6 );
            //Dau_DsdPrintFromTruth( &word2, 6 );
            printf( "Verification failed for output %d (out of %d).\n", i, Gia_ManCoNum(p1) );
            fFailed = 1;
        }
    }
//    if ( !fFailed )
//        printf( "Verification succeeded for %d outputs.\n", Gia_ManCoNum(p1) );
    return !fFailed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_Rsb2AddNode()

int Gia_Rsb2AddNode	(	Vec_Int_t *	vRes,
		int	iLit0,
		int	iLit1,
		int	iRes0,
		int	iRes1 )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 301 of file giaResub2.c.

{
    int iLitMin = iRes0 < iRes1 ? Abc_LitNotCond(iRes0, Abc_LitIsCompl(iLit0)) : Abc_LitNotCond(iRes1, Abc_LitIsCompl(iLit1));
    int iLitMax = iRes0 < iRes1 ? Abc_LitNotCond(iRes1, Abc_LitIsCompl(iLit1)) : Abc_LitNotCond(iRes0, Abc_LitIsCompl(iLit0));
    int iLitRes = Vec_IntSize(vRes);
    if ( iLit0 < iLit1 ) // and
    {
        if ( iLitMin == 0 )
            return 0;
        if ( iLitMin == 1 )
            return iLitMax;
        if ( iLitMin == Abc_LitNot(iLitMax) )
            return 0;
    }
    else if ( iLit0 > iLit1 ) // xor
    {
        if ( iLitMin == 0 )
            return iLitMax;
        if ( iLitMin == 1 )
            return Abc_LitNot(iLitMax);
        if ( iLitMin == Abc_LitNot(iLitMax) )
            return 1;
    }
    else assert( 0 );
    assert( iLitMin >= 2 && iLitMax >= 2 );
    if ( iLit0 < iLit1 ) // and
        Vec_IntPushTwo( vRes, iLitMin, iLitMax );
    else if ( iLit0 > iLit1 ) // xor
    {
        assert( !Abc_LitIsCompl(iLit0) );
        assert( !Abc_LitIsCompl(iLit1) );
        Vec_IntPushTwo( vRes, iLitMax, iLitMin );
    }
    else assert( 0 );
    return iLitRes;
}

Here is the caller graph for this function:

Gia_Rsb2ManAlloc()

Gia_Rsb2Man_t * Gia_Rsb2ManAlloc

(

)

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 83 of file giaResub2.c.

{
    Gia_Rsb2Man_t * p = ABC_CALLOC( Gia_Rsb2Man_t, 1 );
    return p;
}

Here is the caller graph for this function:

Gia_Rsb2ManDeref_rec()

int Gia_Rsb2ManDeref_rec	(	Gia_Rsb2Man_t *	p,
		int *	pObjs,
		int *	pRefs,
		int	iNode )

Definition at line 223 of file giaResub2.c.

{
    int Counter = 1;
    if ( iNode <= p->nPis )
        return 0;
    if ( --pRefs[Abc_Lit2Var(pObjs[2*iNode+0])] == 0 )
        Counter += Gia_Rsb2ManDeref_rec( p, pObjs, pRefs, Abc_Lit2Var(pObjs[2*iNode+0]) );
    if ( --pRefs[Abc_Lit2Var(pObjs[2*iNode+1])] == 0 )
        Counter += Gia_Rsb2ManDeref_rec( p, pObjs, pRefs, Abc_Lit2Var(pObjs[2*iNode+1]) );
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_Rsb2ManDivs()

int Gia_Rsb2ManDivs	(	Gia_Rsb2Man_t *	p,
		int	iNode )

Definition at line 256 of file giaResub2.c.

{
    int i, iNodeLevel = 0;
    int * pRefs = Vec_IntArray( &p->vRefs );
    p->CareSet = Gia_Rsb2ManOdcs( p, iNode );
    p->Truth1 = p->CareSet & Vec_WrdEntry(&p->vSims, 2*iNode);
    p->Truth0 = p->CareSet & ~p->Truth1;
    Vec_PtrClear( &p->vpDivs );
    Vec_PtrPush( &p->vpDivs, &p->Truth0 );
    Vec_PtrPush( &p->vpDivs, &p->Truth1 );
    Vec_IntClear( &p->vDivs );
    Vec_IntPushTwo( &p->vDivs, -1, -1 );
    for ( i = 1; i <= p->nPis; i++ )
    {
        Vec_PtrPush( &p->vpDivs, Vec_WrdEntryP(&p->vSims, 2*i) );
        Vec_IntPush( &p->vDivs, i );
    }
    p->nMffc = Gia_Rsb2ManMffc( p, iNode );
    if ( p->nLevelIncrease >= 0 )
    {
        p->Level = Gia_Rsb2ManLevel(p);
        iNodeLevel = Vec_IntEntry(&p->vLevels, iNode);
    }
    for ( i = p->nPis + 1; i < p->iFirstPo; i++ )
    {
        if ( !pRefs[i] || (p->nLevelIncrease >= 0 && Vec_IntEntry(&p->vLevels, i) > iNodeLevel + p->nLevelIncrease) )
            continue;
        Vec_PtrPush( &p->vpDivs, Vec_WrdEntryP(&p->vSims, 2*i) );
        Vec_IntPush( &p->vDivs, i );
    }
    assert( Vec_IntSize(&p->vDivs) == Vec_PtrSize(&p->vpDivs) );
    return Vec_IntSize(&p->vDivs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_Rsb2ManFree()

void Gia_Rsb2ManFree

(

Gia_Rsb2Man_t *

p

)

Definition at line 88 of file giaResub2.c.

{
    Vec_IntErase( &p->vObjs   );
    Vec_WrdErase( &p->vSims   );
    Vec_PtrErase( &p->vpDivs  );
    Vec_IntErase( &p->vDivs   );
    Vec_IntErase( &p->vLevels );
    Vec_IntErase( &p->vRefs   );
    Vec_IntErase( &p->vCopies );
    Vec_IntErase( &p->vTried );
    ABC_FREE( p );
}

Here is the caller graph for this function:

Gia_Rsb2ManInsert()

Vec_Int_t * Gia_Rsb2ManInsert	(	int	nPis,
		int	nPos,
		Vec_Int_t *	vObjs,
		int	iNode,
		Vec_Int_t *	vResub,
		Vec_Int_t *	vDivs,
		Vec_Int_t *	vCopies )

Definition at line 383 of file giaResub2.c.

{
    int i, nObjs = Vec_IntSize(vObjs)/2, iFirstPo = nObjs - nPos;
    Vec_Int_t * vRes = Vec_IntAlloc( Vec_IntSize(vObjs) );
//Vec_IntPrint( vDivs );
//Vec_IntPrint( vResub );
    Vec_IntFill( vCopies, Vec_IntSize(vObjs), -1 );
    Vec_IntFill( vRes, 2*(nPis + 1), 0 );
    for ( i = 0; i <= nPis; i++ )
        Vec_IntWriteEntry( vCopies, i, 2*i );
    for ( i = iFirstPo; i < nObjs; i++ )
        Gia_Rsb2ManInsert_rec( vRes, nPis, vObjs, iNode, vResub, vDivs, vCopies, Abc_Lit2Var( Vec_IntEntry(vObjs, 2*i) ) );
    for ( i = iFirstPo; i < nObjs; i++ )
    {
        int iLitNew = Abc_Lit2LitL( Vec_IntArray(vCopies), Vec_IntEntry(vObjs, 2*i) );
        Vec_IntPushTwo( vRes, iLitNew, iLitNew );
    }
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_Rsb2ManInsert_rec()

int Gia_Rsb2ManInsert_rec	(	Vec_Int_t *	vRes,
		int	nPis,
		Vec_Int_t *	vObjs,
		int	iNode,
		Vec_Int_t *	vResub,
		Vec_Int_t *	vDivs,
		Vec_Int_t *	vCopies,
		int	iObj )

Definition at line 337 of file giaResub2.c.

{
    if ( Vec_IntEntry(vCopies, iObj) >= 0 )
        return Vec_IntEntry(vCopies, iObj);
    assert( iObj > nPis );
    if ( iObj == iNode )
    {
        int nVars = Vec_IntSize(vDivs);
        int iLitRes = -1, iTopLit = Vec_IntEntryLast( vResub );
        if ( Abc_Lit2Var(iTopLit) == 0 )
            iLitRes = 0;
        else if ( Abc_Lit2Var(iTopLit) < nVars )
            iLitRes = Gia_Rsb2ManInsert_rec( vRes, nPis, vObjs, -1, vResub, vDivs, vCopies, Vec_IntEntry(vDivs, Abc_Lit2Var(iTopLit)) );
        else
        {
            Vec_Int_t * vCopy = Vec_IntAlloc( 10 );
            int k, iLit, iLit0, iLit1;
            Vec_IntForEachEntryStop( vResub, iLit, k, Vec_IntSize(vResub)-1 )
                if ( Abc_Lit2Var(iLit) < nVars )
                    Gia_Rsb2ManInsert_rec( vRes, nPis, vObjs, -1, vResub, vDivs, vCopies, Vec_IntEntry(vDivs, Abc_Lit2Var(iLit)) );
            Vec_IntForEachEntryDouble( vResub, iLit0, iLit1, k )
            {
                int iVar0 = Abc_Lit2Var(iLit0);
                int iVar1 = Abc_Lit2Var(iLit1);
                int iRes0 = iVar0 < nVars ? Vec_IntEntry(vCopies, Vec_IntEntry(vDivs, iVar0)) : Vec_IntEntry(vCopy, iVar0 - nVars);
                int iRes1 = iVar1 < nVars ? Vec_IntEntry(vCopies, Vec_IntEntry(vDivs, iVar1)) : Vec_IntEntry(vCopy, iVar1 - nVars);
                iLitRes   = Gia_Rsb2AddNode( vRes, iLit0, iLit1, iRes0, iRes1 );
                Vec_IntPush( vCopy, iLitRes );
            }
            Vec_IntFree( vCopy );
        }
        iLitRes = Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iTopLit) );
        Vec_IntWriteEntry( vCopies, iObj, iLitRes );
        return iLitRes;
    }
    else
    {
        int iLit0 = Vec_IntEntry( vObjs, 2*iObj+0 );
        int iLit1 = Vec_IntEntry( vObjs, 2*iObj+1 );
        int iRes0 = Gia_Rsb2ManInsert_rec( vRes, nPis, vObjs, iNode, vResub, vDivs, vCopies, Abc_Lit2Var(iLit0) );
        int iRes1 = Gia_Rsb2ManInsert_rec( vRes, nPis, vObjs, iNode, vResub, vDivs, vCopies, Abc_Lit2Var(iLit1) );
        int iLitRes = Gia_Rsb2AddNode( vRes, iLit0, iLit1, iRes0, iRes1 );
        Vec_IntWriteEntry( vCopies, iObj, iLitRes );
        return iLitRes;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_Rsb2ManLevel()

int Gia_Rsb2ManLevel

(

Gia_Rsb2Man_t *

p

)

Definition at line 179 of file giaResub2.c.

{
    int i, * pLevs, Level = 0;
    Vec_IntClear( &p->vLevels );
    Vec_IntGrow( &p->vLevels, p->nObjs );
    pLevs = Vec_IntArray( &p->vLevels );
    for ( i = p->nPis + 1; i < p->iFirstPo; i++ )
        pLevs[i] = 1 + Abc_MaxInt( pLevs[2*i+0]/2, pLevs[2*i+1]/2 );
    for ( i = p->iFirstPo; i < p->nObjs; i++ )
        Level = Abc_MaxInt( Level, pLevs[i] = pLevs[2*i+0]/2 );
    return Level;
}

Here is the caller graph for this function:

Gia_Rsb2ManMffc()

int Gia_Rsb2ManMffc	(	Gia_Rsb2Man_t *	p,
		int	iNode )

Definition at line 234 of file giaResub2.c.

{
    int i, * pRefs, * pObjs;
    Vec_IntFill( &p->vRefs, p->nObjs, 0 );
    pRefs = Vec_IntArray( &p->vRefs );
    pObjs = Vec_IntArray( &p->vObjs );
    assert( pObjs[2*iNode+0] != pObjs[2*iNode+1] );
    for ( i = p->nPis + 1; i < p->iFirstPo; i++ )
        pRefs[Abc_Lit2Var(pObjs[2*i+0])]++, 
        pRefs[Abc_Lit2Var(pObjs[2*i+1])]++;
    for ( i = p->iFirstPo; i < p->nObjs; i++ )
        pRefs[Abc_Lit2Var(pObjs[2*i+0])]++;
    for ( i = p->nPis + 1; i < p->iFirstPo; i++ )
        assert( pRefs[i] );
    pRefs[iNode] = 0;
    for ( i = iNode + 1; i < p->iFirstPo; i++ )
        if ( !pRefs[Abc_Lit2Var(pObjs[2*i+0])] || !pRefs[Abc_Lit2Var(pObjs[2*i+1])] )
            pRefs[i] = 0;
    return Gia_Rsb2ManDeref_rec( p, pObjs, pRefs, iNode );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_Rsb2ManOdcs()

word Gia_Rsb2ManOdcs	(	Gia_Rsb2Man_t *	p,
		int	iNode )

Definition at line 191 of file giaResub2.c.

{
    int i; word Res = 0;
    int  * pObjs = Vec_IntArray( &p->vObjs );
    word * pSims = Vec_WrdArray( &p->vSims );
    for ( i = p->nPis + 1; i < p->iFirstPo; i++ )
    {
        if ( pObjs[2*i+0] < pObjs[2*i+1] )
            pSims[2*i+0] = pSims[pObjs[2*i+0]] & pSims[pObjs[2*i+1]];
        else if ( pObjs[2*i+0] > pObjs[2*i+1] )
            pSims[2*i+0] = pSims[pObjs[2*i+0]] ^ pSims[pObjs[2*i+1]];
        else assert( 0 );
        pSims[2*i+1] = ~pSims[2*i+0];        
    }
    for ( i = p->iFirstPo; i < p->nObjs; i++ )
        pSims[2*i+0] = pSims[pObjs[2*i+0]];
    ABC_SWAP( word, pSims[2*iNode+0], pSims[2*iNode+1] );
    for ( i = iNode + 1; i < p->iFirstPo; i++ )
    {
        if ( pObjs[2*i+0] < pObjs[2*i+1] )
            pSims[2*i+0] = pSims[pObjs[2*i+0]] & pSims[pObjs[2*i+1]];
        else if ( pObjs[2*i+0] < pObjs[2*i+1] )
            pSims[2*i+0] = pSims[pObjs[2*i+0]] ^ pSims[pObjs[2*i+1]];
        else assert( 0 );
        pSims[2*i+1] = ~pSims[2*i+0];        
    }
    for ( i = p->iFirstPo; i < p->nObjs; i++ )
        Res |= pSims[2*i+0] ^ pSims[pObjs[2*i+0]];
    ABC_SWAP( word, pSims[2*iNode+0], pSims[2*iNode+1] );
    return Res;
}

Here is the caller graph for this function:

Gia_Rsb2ManPrint()

void Gia_Rsb2ManPrint

(

Gia_Rsb2Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 166 of file giaResub2.c.

{
    int i, * pObjs = Vec_IntArray( &p->vObjs );
    printf( "PI = %d.  PO = %d.  Obj = %d.\n", p->nPis, p->nPos, p->nObjs );
    for ( i = p->nPis + 1; i < p->iFirstPo; i++ )
        printf( "%2d = %c%2d & %c%2d;\n", i, 
            Abc_LitIsCompl(pObjs[2*i+0]) ? '!' : ' ', Abc_Lit2Var(pObjs[2*i+0]),
            Abc_LitIsCompl(pObjs[2*i+1]) ? '!' : ' ', Abc_Lit2Var(pObjs[2*i+1]) );
    for ( i = p->iFirstPo; i < p->nObjs; i++ )
        printf( "%2d = %c%2d;\n", i, 
            Abc_LitIsCompl(pObjs[2*i+0]) ? '!' : ' ', Abc_Lit2Var(pObjs[2*i+0]) );
}

Gia_Rsb2ManStart()

void Gia_Rsb2ManStart	(	Gia_Rsb2Man_t *	p,
		int *	pObjs,
		int	nObjs,
		int	nDivsMax,
		int	nLevelIncrease,
		int	fUseXor,
		int	fUseZeroCost,
		int	fDebug,
		int	fVerbose )

Definition at line 100 of file giaResub2.c.

{
    int i;
    // hyper-parameters
    p->nDivsMax       = nDivsMax; 
    p->nLevelIncrease = nLevelIncrease; 
    p->fUseXor        = fUseXor; 
    p->fUseZeroCost   = fUseZeroCost; 
    p->fDebug         = fDebug; 
    p->fVerbose       = fVerbose; 
    // user data
    Vec_IntClear( &p->vObjs );
    Vec_IntPushArray( &p->vObjs, pObjs, 2*nObjs );
    assert( pObjs[0] == 0 );
    assert( pObjs[1] == 0 );
    p->nObjs    = nObjs;
    p->nPis     = 0;
    p->nNodes   = 0;
    p->nPos     = 0;
    p->iFirstPo = 0;
    for ( i = 1; i < nObjs; i++ )
    {
        if ( pObjs[2*i+0] == 0 && pObjs[2*i+1] == 0 )
            p->nPis++;
        else if ( pObjs[2*i+0] == pObjs[2*i+1] )
            p->nPos++;
        else
            p->nNodes++;
    }
    assert( nObjs == 1 + p->nPis + p->nNodes + p->nPos );
    p->iFirstPo = nObjs - p->nPos;
    Vec_WrdClear( &p->vSims );
    Vec_WrdGrow( &p->vSims, 2*nObjs );
    Vec_WrdPush( &p->vSims, 0 );
    Vec_WrdPush( &p->vSims, 0 );
    for ( i = 0; i < p->nPis; i++ )
    {
        Vec_WrdPush( &p->vSims,  s_Truths6[i] );
        Vec_WrdPush( &p->vSims, ~s_Truths6[i] );
    }
    p->vSims.nSize = 2*p->nObjs;
    Vec_IntClear( &p->vDivs   );
    Vec_IntClear( &p->vLevels );
    Vec_IntClear( &p->vRefs   );
    Vec_IntClear( &p->vCopies );
    Vec_IntClear( &p->vTried  );
    Vec_PtrClear( &p->vpDivs  );
    Vec_IntGrow( &p->vDivs,   nObjs );
    Vec_IntGrow( &p->vLevels, nObjs );
    Vec_IntGrow( &p->vRefs,   nObjs );
    Vec_IntGrow( &p->vCopies, nObjs );
    Vec_IntGrow( &p->vTried,  nObjs );
    Vec_PtrGrow( &p->vpDivs,  nObjs );
}

Here is the caller graph for this function:

Gia_RsbAddSideInputs()

void Gia_RsbAddSideInputs	(	Gia_Man_t *	p,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vWin )

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

Synopsis [Grow window for the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 866 of file giaResub2.c.

{
    Vec_Int_t * vLevel; 
    Gia_Obj_t * pObj, * pFanout;
    int k, i, f, iObj;
    // precondition: the levelized structure is empty
    assert( Vec_WecSizeSize(vLevels) == 0 );
    // precondition: window nodes are labeled with the current ID
    Vec_IntForEachEntry( vWin, iObj, i )
    {
        assert( Gia_ObjIsTravIdCurrentId(p, iObj) );
        Vec_WecPush( vLevels, Gia_ObjLevelId(p, iObj), iObj );
    }
    // iterate through all objects and explore their fanouts
    Vec_WecForEachLevel( vLevels, vLevel, k )
        Gia_ManForEachObjVec( vLevel, p, pObj, i )
            Gia_ObjForEachFanoutStatic( p, pObj, pFanout, f )
            {
                if ( f == 5 ) // explore first 5 fanouts of the node
                    break;
                if ( Gia_ObjIsAnd(pFanout) && // internal node
                    !Gia_ObjIsTravIdCurrent(p, pFanout) && // not in the window
                     Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin0(pFanout)) && // but fanins are
                     Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin1(pFanout)) )  // in the window
                {
                    // add fanout to the window and to the levelized structure
                    Gia_ObjSetTravIdCurrent( p, pFanout );
                    Vec_WecPush( vLevels, Gia_ObjLevel(p, pFanout), Gia_ObjId(p, pFanout) );
                    Vec_IntPush( vWin, Gia_ObjId(p, pFanout) );
                }
            }
    // iterate through the nodes in the levelized structure
    Vec_WecForEachLevel( vLevels, vLevel, k )
        Vec_IntClear( vLevel );
}

Here is the caller graph for this function:

Gia_RsbCiTranslate()

Vec_Int_t * Gia_RsbCiTranslate	(	Gia_Man_t *	p,
		Vec_Int_t *	vObjs,
		Vec_Int_t *	vMap )

Definition at line 665 of file giaResub2.c.

{
    int i, iObj, Lit0, Lit1, Fan0, Fan1;
    Vec_Int_t * vNodes = Vec_IntAlloc( 100 );
    assert( Vec_IntSize(vMap) == Gia_ManObjNum(p) );
    Vec_IntPushTwo( vNodes, 0, 0 ); // const0 node
    Vec_IntForEachEntry( vObjs, iObj, i )
    {
        Gia_Obj_t * pObj = Gia_ManObj(p, iObj);
        assert( Gia_ObjIsTravIdCurrentId(p, iObj) );
        Fan0 = Gia_ObjIsCi(pObj) ? 0 : Vec_IntEntry(vMap, Gia_ObjFaninId0(pObj, iObj));
        Fan1 = Gia_ObjIsCi(pObj) ? 0 : Vec_IntEntry(vMap, Gia_ObjFaninId1(pObj, iObj));
        Lit0 = Gia_ObjIsCi(pObj) ? 0 : Abc_LitNotCond( Fan0, Gia_ObjFaninC0(pObj) );
        Lit1 = Gia_ObjIsCi(pObj) ? 0 : Abc_LitNotCond( Fan1, Gia_ObjFaninC1(pObj) );
        Vec_IntWriteEntry( vMap, iObj, Vec_IntSize(vNodes) );
        Vec_IntPushTwo( vNodes, Lit0, Lit1 );
    }
    Vec_IntForEachEntry( vObjs, iObj, i )
        if ( Gia_WinNodeHasUnmarkedFanouts( p, iObj ) )
            Vec_IntPushTwo( vNodes, Vec_IntEntry(vMap, iObj), Vec_IntEntry(vMap, iObj) );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbCiWindow()

Vec_Int_t * Gia_RsbCiWindow	(	Gia_Man_t *	p,
		int	nPis )

Definition at line 688 of file giaResub2.c.

{
    Vec_Int_t * vRes;  int i, iMaxFan;
    Vec_Int_t * vNodes  = Vec_IntAlloc( 100 );
    Vec_Int_t * vMap    = Vec_IntStartFull( Gia_ManObjNum(p) );
    Vec_Wec_t * vLevels = Vec_WecStart( Gia_ManLevelNum(p)+1 );
    Gia_ManStaticFanoutStart( p );
    Gia_ManIncrementTravId(p);
    // add the first one
    iMaxFan = Gia_WinAddCiWithMaxFanouts( p );
    Gia_ObjSetTravIdCurrentId( p, iMaxFan );
    Vec_IntPush( vNodes, iMaxFan );
    // add remaining ones
    for ( i = 1; i < nPis; i++ )
    {
        iMaxFan = Gia_WinAddCiWithMaxDivisors( p, vLevels );
        Gia_WinTryAddingNode( p, iMaxFan, -1, vLevels, vNodes );
    }
    Vec_IntSort( vNodes, 0 );
    vRes = Gia_RsbCiTranslate( p, vNodes, vMap );
    Gia_ManStaticFanoutStop( p );
    Vec_WecFree( vLevels );
    Vec_IntFree( vMap );
//Vec_IntPrint( vNodes );
    Vec_IntFree( vNodes );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbCiWindowTest()

void Gia_RsbCiWindowTest

(

Gia_Man_t *

p

)

Definition at line 715 of file giaResub2.c.

{
    Vec_Int_t * vWin = Gia_RsbCiWindow( p, 6 );
    //Vec_IntPrint( vWin );
    Vec_IntFree( vWin );
}

Here is the call graph for this function:

Gia_RsbCreateWindowInputs()

Vec_Int_t * Gia_RsbCreateWindowInputs	(	Gia_Man_t *	p,
		Vec_Int_t *	vWin )

Definition at line 830 of file giaResub2.c.

{
    Vec_Int_t * vInputs = Vec_IntAlloc(10);
    Gia_Obj_t * pObj; int i, n, iObj;
    Gia_ManIncrementTravId(p);
    Gia_ManForEachObjVec( vWin, p, pObj, i )
        Gia_ObjSetTravIdCurrent(p, pObj);
    Gia_ManForEachObjVec( vWin, p, pObj, i )
    {
        assert( Gia_ObjIsAnd(pObj) );
        for ( n = 0; n < 2; n++ )
        {
            int iFan = n ? Gia_ObjFaninId1p(p, pObj) : Gia_ObjFaninId0p(p, pObj);
            if ( !Gia_ObjIsTravIdCurrentId(p, iFan) )
                Vec_IntPushUnique( vInputs, iFan );
        }
    }
    Vec_IntForEachEntry( vInputs, iObj, i )
    {
        Gia_ObjSetTravIdCurrentId( p, iObj );
        Vec_IntPush( vWin, iObj );
    }
    return vInputs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbDeriveGiaFromWindows()

Gia_Man_t * Gia_RsbDeriveGiaFromWindows	(	Gia_Man_t *	p,
		Vec_Int_t *	vWin,
		Vec_Int_t *	vIns,
		Vec_Int_t *	vOuts )

Definition at line 1264 of file giaResub2.c.

{
    Gia_Man_t * pNew; 
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObjVec( vIns, p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachObjVec( vWin, p, pObj, i )
        if ( !~pObj->Value )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachObjVec( vOuts, p, pObj, i )
        Gia_ManAppendCo( pNew, pObj->Value );
    Gia_ManHashStop( pNew );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbEnumerateWindows()

void Gia_RsbEnumerateWindows	(	Gia_Man_t *	p,
		int	nInputsMax,
		int	nLevelsMax )

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

Synopsis [Enumerate windows of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1353 of file giaResub2.c.

{
    int fVerbose = 0;
    int fUseHash = 0;
    int i, nWins = 0, nWinSize = 0, nInsSize = 0, nOutSize = 0, nNodeGain = 0;
    Vec_Wec_t * vLevels = Vec_WecStart( Gia_ManLevelNum(p)+1 );
    Vec_Int_t * vPaths = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vRefs = Vec_IntStart( Gia_ManObjNum(p) );
    Hsh_VecMan_t * pHash = Hsh_VecManStart( 1000 );
    Gia_Obj_t * pObj;
    Gia_Man_t * pIn, * pOut;
    abctime clk = Abc_Clock();
    Gia_ManStaticFanoutStart( p );
    Gia_ManForEachAnd( p, pObj, i )
    {
        Vec_Int_t * vWin, * vIns, * vOuts;
        if ( !Gia_RsbWindowCompute( p, i, nInputsMax, nLevelsMax, vLevels, vPaths, &vWin, &vIns ) )
            continue;
        vOuts = Gia_RsbFindOutputs( p, vWin, vIns, vRefs );
        nWins++;
        nWinSize += Vec_IntSize(vWin);
        nInsSize += Vec_IntSize(vIns);
        nOutSize += Vec_IntSize(vOuts);
   
 
        if ( fVerbose )
        {
            printf( "\n\nObj %d\n", i );
            Vec_IntPrint( vWin );    
            Vec_IntPrint( vIns );    
            Vec_IntPrint( vOuts );    
            printf( "\n" );
        }
        else if ( Vec_IntSize(vWin) > 1000 )
            printf( "Obj %d.   Window: Ins = %d. Ands = %d. Outs = %d.\n", 
                i, Vec_IntSize(vIns), Vec_IntSize(vWin)-Vec_IntSize(vIns), Vec_IntSize(vOuts) );
 
        if ( fUseHash )
        {
            int nEntries = Hsh_VecSize(pHash);
            Hsh_VecManAdd( pHash, vWin );
            if ( nEntries == Hsh_VecSize(pHash) )
            {
                Vec_IntFree( vWin );
                Vec_IntFree( vIns );
                Vec_IntFree( vOuts );
                continue;
            }
        }
 
        pIn = Gia_RsbDeriveGiaFromWindows( p, vWin, vIns, vOuts );
        pOut = Gia_ManResub2Test( pIn );
        //pOut = Gia_ManDup( pIn );
        if ( !Gia_ManVerifyTwoTruths( pIn, pOut ) )
        {
            Gia_ManPrint( pIn );
            Gia_ManPrint( pOut );
            pOut = pOut;
        }
 
        nNodeGain += Gia_ManAndNum(pIn) - Gia_ManAndNum(pOut);
        Gia_ManStop( pIn );
        Gia_ManStop( pOut );
 
        Vec_IntFree( vWin );
        Vec_IntFree( vIns );
        Vec_IntFree( vOuts );
    }
    Gia_ManStaticFanoutStop( p );
    Vec_WecFree( vLevels );
    Vec_IntFree( vPaths );
    Vec_IntFree( vRefs );
    printf( "Computed windows for %d nodes (out of %d). Unique = %d. Ave inputs = %.2f. Ave outputs = %.2f. Ave volume = %.2f.  Gain = %d. ", 
        nWins, Gia_ManAndNum(p), Hsh_VecSize(pHash), 1.0*nInsSize/Abc_MaxInt(1,nWins), 
        1.0*nOutSize/Abc_MaxInt(1,nWins), 1.0*nWinSize/Abc_MaxInt(1,nWins), nNodeGain );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    Hsh_VecManStop( pHash );
}

Here is the call graph for this function:

Gia_RsbExpandCut()

int Gia_RsbExpandCut	(	Gia_Man_t *	p,
		Vec_Int_t *	vIns )

Definition at line 1048 of file giaResub2.c.

{
    int fOnlyPis = 0, fChange = 1, nSize = Vec_IntSize(vIns);
    while ( fChange )
    {
        Gia_Obj_t * pObj;
        int i, iFan0, iFan1, fHave0, fHave1;
        fOnlyPis = 1;
        fChange = 0;
        // check if some nodes can be expanded without increasing cut size
        Gia_ManForEachObjVec( vIns, p, pObj, i )
        {
            assert( Gia_ObjIsTravIdCurrent(p, pObj) );
            if ( !Gia_ObjIsAnd(pObj) )
                continue;
            fOnlyPis = 0;
            iFan0 = Gia_ObjFaninId0p(p, pObj);
            iFan1 = Gia_ObjFaninId1p(p, pObj);
            fHave0 = Gia_ObjIsTravIdCurrentId(p, iFan0);
            fHave1 = Gia_ObjIsTravIdCurrentId(p, iFan1);
            if ( !fHave0 && !fHave1 )
                continue;
            // can expand because one of the fanins is already in the cut
            // remove current cut node
            Vec_IntDrop( vIns, i );
            // add missing fanin
            if ( !fHave0 )  
            {
                Vec_IntPush( vIns, iFan0 );
                Gia_ObjSetTravIdCurrentId( p, iFan0 );
            }
            if ( !fHave1 )  
            {
                Vec_IntPush( vIns, iFan1 );
                Gia_ObjSetTravIdCurrentId( p, iFan1 );
            }
            fChange = 1;
            break;
        }
    }
    assert( Vec_IntSize(vIns) <= nSize );
    return fOnlyPis;
}

Here is the caller graph for this function:

Gia_RsbExpandInputs()

void Gia_RsbExpandInputs	(	Gia_Man_t *	p,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vWin,
		Vec_Int_t *	vInputs )

Definition at line 902 of file giaResub2.c.

{
    Gia_Obj_t * pObj; 
    int i, n, iFans[2], fChange = 1;
    while ( fChange )
    {
        fChange = 0;
        Gia_ManForEachObjVec( vInputs, p, pObj, i )
        {
            if ( !Gia_ObjIsAnd(pObj) )
                continue;
            iFans[0] = Gia_ObjFaninId0p(p, pObj);
            iFans[1] = Gia_ObjFaninId1p(p, pObj);
            if ( !Gia_ObjIsTravIdCurrentId(p, iFans[0]) && !Gia_ObjIsTravIdCurrentId(p, iFans[1]) )
                continue;
            Vec_IntRemove( vInputs, Gia_ObjId(p, pObj) );
            assert( Vec_IntFind(vWin, Gia_ObjId(p, pObj)) >= 0 );
            for ( n = 0; n < 2; n++ )
            {
                if ( Gia_ObjIsTravIdCurrentId(p, iFans[n]) )
                    continue;
                assert( Vec_IntFind(vInputs, iFans[n]) == -1 );
                Vec_IntPush( vInputs, iFans[n] );
                Gia_WinTryAddingNode( p, iFans[n], -1, vLevels, vWin );
                assert( Gia_ObjIsTravIdCurrentId(p, iFans[n]) );
            }
            fChange = 1;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbFindFaninAdd()

int Gia_RsbFindFaninAdd	(	int	iFan,
		int	pFanins[32],
		int	pFaninCounts[32],
		int	nFanins )

Definition at line 1091 of file giaResub2.c.

{
    int i;
    for ( i = 0; i < nFanins; i++ )
        if ( pFanins[i] == iFan )
            break;
    pFanins[i] = iFan;
    pFaninCounts[i]++;
    return nFanins + (i == nFanins);
}                        

Here is the caller graph for this function:

Gia_RsbFindFaninToAddToCut()

int Gia_RsbFindFaninToAddToCut	(	Gia_Man_t *	p,
		Vec_Int_t *	vIns )

Definition at line 1101 of file giaResub2.c.

{
    Gia_Obj_t * pObj;
    int nFanins = 0, pFanins[64] = {0}, pFaninCounts[64] = {0};
    int i, iFan0, iFan1, iFanMax = -1, CountMax = 0;
    Gia_ManForEachObjVec( vIns, p, pObj, i )
    {
        if ( !Gia_ObjIsAnd(pObj) )
            continue;
        iFan0 = Gia_ObjFaninId0p(p, pObj);
        iFan1 = Gia_ObjFaninId1p(p, pObj);
        assert( !Gia_ObjIsTravIdCurrentId(p, iFan0) );
        assert( !Gia_ObjIsTravIdCurrentId(p, iFan1) );
        nFanins = Gia_RsbFindFaninAdd( iFan0, pFanins, pFaninCounts, nFanins );
        nFanins = Gia_RsbFindFaninAdd( iFan1, pFanins, pFaninCounts, nFanins );
        assert( nFanins < 64 );
    }
    // find fanin with the highest count
    if ( p->vFanoutNums != NULL )
    {
        for ( i = 0; i < nFanins; i++ )
            if ( CountMax < pFaninCounts[i] || (CountMax == pFaninCounts[i] && (Gia_ObjFanoutNumId(p, iFanMax) < Gia_ObjFanoutNumId(p, pFanins[i]))) )
            {
                CountMax = pFaninCounts[i];
                iFanMax  = pFanins[i];
            }
    }
    else
    {
        for ( i = 0; i < nFanins; i++ )
            if ( CountMax < pFaninCounts[i] || (CountMax == pFaninCounts[i] && (Gia_ObjRefNumId(p, iFanMax) < Gia_ObjRefNumId(p, pFanins[i]))) )
            {
                CountMax = pFaninCounts[i];
                iFanMax  = pFanins[i];
            }
    }
    return iFanMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbFindOutputs()

Vec_Int_t * Gia_RsbFindOutputs	(	Gia_Man_t *	p,
		Vec_Int_t *	vWin,
		Vec_Int_t *	vIns,
		Vec_Int_t *	vRefs )

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

Synopsis [Derive GIA from the window]

Description []

SideEffects []

SeeAlso []

Definition at line 1239 of file giaResub2.c.

{
    Vec_Int_t * vOuts = Vec_IntAlloc( 100 );
    Gia_Obj_t * pObj; int i;
    Gia_ManIncrementTravId( p );
    Gia_ManForEachObjVec( vIns, p, pObj, i ) 
        Gia_ObjSetTravIdCurrent( p, pObj );
    Gia_ManForEachObjVec( vWin, p, pObj, i ) 
        if ( !Gia_ObjIsTravIdCurrent(p, pObj) && Gia_ObjIsAnd(pObj) )
        {
            Vec_IntAddToEntry( vRefs, Gia_ObjFaninId0p(p, pObj), 1 );
            Vec_IntAddToEntry( vRefs, Gia_ObjFaninId1p(p, pObj), 1 );
        }
    Gia_ManForEachObjVec( vWin, p, pObj, i )
        if ( !Gia_ObjIsTravIdCurrent(p, pObj) && Gia_ObjFanoutNum(p, pObj) != Vec_IntEntry(vRefs, Gia_ObjId(p, pObj)) )
            Vec_IntPush( vOuts, Gia_ObjId(p, pObj) );
    Gia_ManForEachObjVec( vWin, p, pObj, i )
        if ( !Gia_ObjIsTravIdCurrent(p, pObj) && Gia_ObjIsAnd(pObj) )
        {
            Vec_IntAddToEntry( vRefs, Gia_ObjFaninId0p(p, pObj), -1 );
            Vec_IntAddToEntry( vRefs, Gia_ObjFaninId1p(p, pObj), -1 );
        }
    return vOuts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbSelectOneInput()

int Gia_RsbSelectOneInput	(	Gia_Man_t *	p,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vIns )

Definition at line 933 of file giaResub2.c.

{
    int i, iNode = 0, WeightThis, WeightBest = -1;
    Gia_Obj_t * pObj; 
    Gia_ManForEachObjVec( vIns, p, pObj, i )
        if ( Gia_ObjIsAnd(pObj) )
        {
            int iFan0 = Gia_ObjFaninId0p(p, pObj);
            int iFan1 = Gia_ObjFaninId1p(p, pObj);
            assert( !Gia_ObjIsTravIdCurrentId(p, iFan0) && !Gia_ObjIsTravIdCurrentId(p, iFan1) );
            WeightThis = Gia_WinTryAddingNode( p, iFan0, iFan1, vLevels, NULL );
            if ( WeightBest < WeightThis )
            {
                WeightBest = WeightThis;
                iNode = Gia_ObjId(p, pObj);
            }
        }
    return iNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbTestArray()

void Gia_RsbTestArray

(

)

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

Synopsis [Apply k-resub to one AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 1459 of file giaResub2.c.

{
    int Array[1000] = { 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 3, 7, 15, 17, 8, 19, 
        5, 20, 5, 12, 8, 24, 4, 12, 9, 28, 27, 31, 23, 32, 4, 13, 8, 36, 5, 
        13, 18, 40, 9, 18, 5, 44, 19, 36, 9, 48, 47, 51, 10, 18, 40, 54, 8, 
        56, 25, 37, 44, 61, 59, 63, 8, 28, 8, 18, 25, 68, 66, 70, 64, 73, 11, 
        19, 8, 13, 76, 78, 10, 19, 40, 82, 9, 84, 81, 87, 20, 61, 19, 28, 30, 
        92, 91, 95, 88, 96, 74, 98, 9, 40, 49, 103, 27, 104, 10, 107, 8, 40, 
        9, 24, 111, 113, 11, 115, 109, 117, 11, 66, 51, 121, 118, 122, 18, 36, 
        18, 110, 93, 127, 10, 131, 129, 133, 11, 38, 32, 137, 103, 138, 19, 141, 
        134, 143, 28, 76, 9, 146, 11, 110, 19, 150, 149, 153, 87, 95, 9, 19, 10, 
        159, 61, 160, 18, 30, 61, 158, 9, 12, 25, 169, 19, 171, 111, 173, 10, 175, 
        167, 177, 18, 102, 4, 20, 18, 171, 183, 185, 11, 187, 181, 189, 178, 190, 
        24, 44, 11, 194, 8, 54, 4, 198, 197, 201, 45, 49, 10, 39, 9, 126, 73, 209, 
        11, 211, 54, 168, 213, 215, 43, 167, 67, 218, 10, 221, 26, 54, 18, 18, 34, 
        34, 38, 38, 40, 40, 42, 42, 52, 52, 100, 100, 124, 124, 126, 126, 144, 144, 
        148, 148, 154, 154, 156, 156, 162, 162, 164, 164, 192, 192, 70, 70, 202, 
        202, 204, 204, 206, 206, 216, 216, 222, 222, 224, 224
    };
    int i, iFan0, iFan1, nResubs;
    int * pRes;
    // create the internal array
    Vec_Int_t * vArray = Vec_IntAlloc( 100 );
    for ( i = 0; i < 50 || Array[i] > 0; i++ )
        Vec_IntPush( vArray, Array[i] );
    Vec_IntPrint( vArray );
    // check the nodes
    printf( "Constant0 and primary inputs:\n" );
    Vec_IntForEachEntryDouble( vArray, iFan0, iFan1, i )
    {
        if ( iFan0 != iFan1 )
            break;
        printf( "%2d = %c%2d & %c%2d;\n", i, 
            Abc_LitIsCompl(iFan0) ? '!' : ' ', Abc_Lit2Var(iFan0),
            Abc_LitIsCompl(iFan1) ? '!' : ' ', Abc_Lit2Var(iFan1) );
    }
    printf( "Primary outputs:\n" );
    Vec_IntForEachEntryDoubleStart( vArray, iFan0, iFan1, i, 14 )
    {
        if ( iFan0 != iFan1 )
            continue;
        printf( "%2d = %c%2d & %c%2d;\n", i, 
            Abc_LitIsCompl(iFan0) ? '!' : ' ', Abc_Lit2Var(iFan0),
            Abc_LitIsCompl(iFan1) ? '!' : ' ', Abc_Lit2Var(iFan1) );
    }
    // run the resub
    Abc_ResubPrepareManager( 1 );
    Abc_ResubComputeWindow( Vec_IntArray(vArray), Vec_IntSize(vArray)/2, 10, -1, 0, 0, 1, 1, &pRes, &nResubs );
    Abc_ResubPrepareManager( 0 );
    Vec_IntFree( vArray );
}

Here is the call graph for this function:

Gia_RsbTryOneWindow()

Gia_Man_t * Gia_RsbTryOneWindow

(

Gia_Man_t *

p

)

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

Synopsis [Apply k-resub to one AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 1443 of file giaResub2.c.

{
    return Gia_ManResub2Test( p );
}

Here is the call graph for this function:

Gia_RsbWindowCompute()

int Gia_RsbWindowCompute	(	Gia_Man_t *	p,
		int	iObj,
		int	nInputsMax,
		int	nLevelsMax,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vPaths,
		Vec_Int_t **	pvWin,
		Vec_Int_t **	pvIns )

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

Synopsis [Create window for the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1199 of file giaResub2.c.

{
    Vec_Int_t * vWin, * vIns;
    *pvWin = *pvIns = NULL;
    vWin = Gia_RsbWindowInit( p, vPaths, iObj, nLevelsMax );
    if ( vWin == NULL )
        return 0;
    vIns = Gia_RsbCreateWindowInputs( p, vWin ); 
    // vWin and vIns are labeled with the current trav ID
    //Vec_IntPrint( vWin );    
    //Vec_IntPrint( vIns );    
    if ( Vec_IntSize(vIns) <= nInputsMax + 3 ) // consider windows, which initially has a larger input space
        Gia_RsbWindowGrow2( p, iObj, vLevels, vWin, vIns, nInputsMax );
    if ( Vec_IntSize(vIns) <= nInputsMax )
    {
        Vec_IntSort( vWin, 0 );
        Vec_IntSort( vIns, 0 );
        *pvWin = vWin;
        *pvIns = vIns;
        return 1;
    }
    else
    {
        Vec_IntFree( vWin );
        Vec_IntFree( vIns );
        return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbWindowExplore()

int Gia_RsbWindowExplore	(	Gia_Man_t *	p,
		Vec_Int_t *	vVisited,
		int	iStart,
		Vec_Int_t *	vPaths,
		int *	piMeet,
		int *	piNode )

Definition at line 756 of file giaResub2.c.

{
    int i, n, iObj, iLimit = Vec_IntSize( vVisited );
    *piMeet = *piNode = 0;
    Vec_IntForEachEntryStartStop( vVisited, iObj, i, iStart, iLimit )
    {
        Gia_Obj_t * pObj = Gia_ManObj( p, iObj );
        if ( !Gia_ObjIsAnd(pObj) )
            continue;
        for ( n = 0; n < 2; n++ )
        {
            int iFan = Gia_ObjFaninId( pObj, iObj, n );
            // if the node was visited on the paths to both fanins, collect it
            if ( Gia_ObjTravIsTopTwo(p, iObj) && Gia_ObjTravIsTopTwo(p, iFan) && !Gia_ObjTravIsSame(p, iObj, iFan) )
            {
                *piMeet = iFan;
                *piNode = iObj;
                return 1;
            }
            // if the node was visited already on this path, skip it
            if ( Gia_ObjTravIsTopTwo(p, iFan) )
            {
                assert( Gia_ObjTravIsSame(p, iObj, iFan) );
                continue;
            }
            // label the node as visited
            Gia_ObjTravSetSame( p, iFan, iObj );
            Vec_IntWriteEntry( vPaths, iFan, iObj ); 
            Vec_IntPush( vVisited, iFan );
        }
    }
    return 0;
}

Here is the caller graph for this function:

Gia_RsbWindowGather()

void Gia_RsbWindowGather	(	Gia_Man_t *	p,
		Vec_Int_t *	vPaths,
		int	iNode,
		Vec_Int_t *	vVisited )

Definition at line 743 of file giaResub2.c.

{
    int iPrev;
    if ( iNode == 0 )
        return;
    Vec_IntPush( vVisited, iNode );
    iPrev = Vec_IntEntry( vPaths, iNode );
    if ( iPrev == 0 )
        return;
    assert( Gia_ObjTravIsSame(p, iPrev, iNode) );
    Gia_RsbWindowGather( p, vPaths, iPrev, vVisited );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbWindowGrow()

void Gia_RsbWindowGrow	(	Gia_Man_t *	p,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vWin,
		Vec_Int_t *	vIns,
		int	nInputsMax )

Definition at line 953 of file giaResub2.c.

{
    int iNode;
    Gia_RsbAddSideInputs( p, vLevels, vWin );
    Gia_RsbExpandInputs( p, vLevels, vWin, vIns );
    while ( Vec_IntSize(vIns) < nInputsMax && (iNode = Gia_RsbSelectOneInput(p, vLevels, vIns)) )
    {
        int iFan0 = Gia_ObjFaninId0p(p, Gia_ManObj(p, iNode));
        int iFan1 = Gia_ObjFaninId1p(p, Gia_ManObj(p, iNode));
        assert( !Gia_ObjIsTravIdCurrentId(p, iFan0) && !Gia_ObjIsTravIdCurrentId(p, iFan1) );
        Gia_WinTryAddingNode( p, iFan0, iFan1, vLevels, vWin );
        assert(  Gia_ObjIsTravIdCurrentId(p, iFan0) &&  Gia_ObjIsTravIdCurrentId(p, iFan1) );
        Vec_IntRemove( vIns, iNode );
        Vec_IntPushTwo( vIns, iFan0, iFan1 );
        Gia_RsbExpandInputs( p, vLevels, vWin, vIns );
    }
}

Here is the call graph for this function:

Gia_RsbWindowGrow2()

void Gia_RsbWindowGrow2	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vWin,
		Vec_Int_t *	vIns,
		int	nInputsMax )

Definition at line 1140 of file giaResub2.c.

{
    // window will be recomputed later
    Vec_IntClear( vWin );
    // expand the cut without increasing its cost
    if ( !Gia_RsbExpandCut( p, vIns ) )
    {
        // save it as the best cut
        Vec_Int_t * vBest = Vec_IntSize(vIns) <= nInputsMax ? Vec_IntDup(vIns) : NULL;
        int fOnlyPis = 0, Iter = 0;
        // iterate expansion until  
        // (1) the cut cannot be expanded because all leaves are PIs
        // (2) the cut size exceeded the limit for 5 consecutive iterations
        while ( !fOnlyPis && (Vec_IntSize(vIns) <= nInputsMax || Iter < 5) )
        {
            int iFanBest = Gia_RsbFindFaninToAddToCut( p, vIns );
            Vec_IntPush( vIns, iFanBest );
            Gia_ObjSetTravIdCurrentId( p, iFanBest );
            fOnlyPis = Gia_RsbExpandCut( p, vIns );
            if ( Vec_IntSize(vIns) > nInputsMax )
                Iter++;
            else
                Iter = 0;                
            if ( Vec_IntSize(vIns) <= nInputsMax && (!vBest || Vec_IntSize(vBest) <= Vec_IntSize(vIns)) )
            {
                if ( vBest )
                    Vec_IntClear(vBest);
                else
                    vBest = Vec_IntAlloc( 10 );
                Vec_IntAppend( vBest, vIns );
            }
        }
        if ( vBest )
        {
            Vec_IntClear( vIns );
            Vec_IntAppend( vIns, vBest );
            Vec_IntFree( vBest );
        }
        else
            assert( Vec_IntSize(vIns) > nInputsMax );
    }
    if ( vLevels && Vec_IntSize(vIns) <= nInputsMax )
    {
        Vec_IntSort( vIns, 0 );
        Gia_WinCreateFromCut( p, iObj, vIns, vLevels, vWin );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_RsbWindowInit()

Vec_Int_t * Gia_RsbWindowInit	(	Gia_Man_t *	p,
		Vec_Int_t *	vPaths,
		int	iPivot,
		int	nIter )

Definition at line 789 of file giaResub2.c.

{
    Vec_Int_t * vVisited = Vec_IntAlloc( 100 );
    Gia_Obj_t * pPivot = Gia_ManObj( p, iPivot ); 
    int i, n, iStart = 0;
    assert( Gia_ObjIsAnd(pPivot) );
    // start paths for both fanins of the pivot node
    for ( n = 0; n < 2; n++ )
    {
        int iFan = Gia_ObjFaninId( pPivot, iPivot, n );
        Gia_ManIncrementTravId(p);
        Vec_IntPush( vVisited, iFan );
        Vec_IntWriteEntry( vPaths, iFan, 0 ); 
        Gia_ObjSetTravIdCurrentId( p, iFan );
    }
    // perform several iterations of breadth-first search
    for ( i = 0; i < nIter; i++ )
    {
        int iMeet, iNode, iNext = Vec_IntSize(vVisited);
        if ( Gia_RsbWindowExplore( p, vVisited, iStart, vPaths, &iMeet, &iNode ) )
        {
            // found the shared path
            if ( Gia_ObjIsTravIdCurrentId(p, iMeet) )
                assert( Gia_ObjIsTravIdPreviousId(p, iNode) );
            else if ( Gia_ObjIsTravIdPreviousId(p, iMeet) )
                assert( Gia_ObjIsTravIdCurrentId(p, iNode) );
            else assert( 0 );
            // collect the initial window
            Vec_IntClear( vVisited );
            Gia_RsbWindowGather( p, vPaths, Vec_IntEntry(vPaths, iMeet), vVisited );
            Gia_RsbWindowGather( p, vPaths, iNode, vVisited );
            Vec_IntPush( vVisited, iPivot );
            break;
        }
        iStart = iNext;
    }
    // if no meeting point is found, make sure to return NULL
    if ( i == nIter )
        Vec_IntFreeP( &vVisited );
    return vVisited;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_WinAddCiWithMaxDivisors()

int Gia_WinAddCiWithMaxDivisors	(	Gia_Man_t *	p,
		Vec_Wec_t *	vLevels )

Definition at line 636 of file giaResub2.c.

{
    int i, Id, nCurFan, nMaxFan = -1, iMaxFan = -1;
    Gia_ManForEachCiId( p, Id, i )
    {
        if ( Gia_ObjIsTravIdCurrentId( p, Id ) )
            continue;
        nCurFan = Gia_WinTryAddingNode( p, Id, -1, vLevels, NULL );
        if ( nMaxFan < nCurFan )
        {
            nMaxFan = nCurFan;
            iMaxFan = Id;
        }
    }
    assert( iMaxFan >= 0 );
    return iMaxFan;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_WinAddCiWithMaxFanouts()

int Gia_WinAddCiWithMaxFanouts

(

Gia_Man_t *

p

)

Definition at line 623 of file giaResub2.c.

{
    int i, Id, nMaxFan = -1, iMaxFan = -1;
    Gia_ManForEachCiId( p, Id, i )
        if ( nMaxFan < Gia_ObjFanoutNumId(p, Id) )
        {
            nMaxFan = Gia_ObjFanoutNumId(p, Id);
            iMaxFan = Id;
        }
    assert( iMaxFan >= 0 );
    return iMaxFan;
}

Here is the caller graph for this function:

Gia_WinCreateFromCut()

void Gia_WinCreateFromCut	(	Gia_Man_t *	p,
		int	iPivot,
		Vec_Int_t *	vIn,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vWin )

Definition at line 995 of file giaResub2.c.

{
    Vec_Int_t * vLevel; 
    Gia_Obj_t * pObj, * pFanout;
    int k, i, f, iObj, Level;
    Vec_Int_t * vUsed = Vec_IntAlloc( 100 );
    // precondition:  the levelized structure is empty
    assert( Vec_WecSizeSize(vLevels) == 0 );
    // clean the resulting array
    Vec_IntClear( vWin );
    // collect leaves
    Gia_ManIncrementTravId( p );
    Vec_IntForEachEntry( vIn, iObj, i )
    {
        Gia_ObjSetTravIdCurrentId( p, iObj );
        Vec_IntPush( vWin, iObj );
    }
    // collect internal cone
    Gia_WinCreateFromCut_rec( p, iPivot, vWin );
    // add nodes to the levelized structure
    Vec_IntForEachEntry( vWin, iObj, i )
    {
        Vec_WecPush( vLevels, Gia_ObjLevelId(p, iObj), iObj );
        Vec_IntPushUniqueOrder( vUsed, Gia_ObjLevelId(p, iObj) );
    }
    // iterate through all objects and explore their fanouts
    //Vec_WecForEachLevel( vLevels, vLevel, k )
    Vec_IntForEachEntry( vUsed, Level, k )
    {
        vLevel = Vec_WecEntry( vLevels, Level );
        Gia_ManForEachObjVec( vLevel, p, pObj, i )
            Gia_ObjForEachFanoutStatic( p, pObj, pFanout, f )
            {
                if ( f == 5 ) // explore first 5 fanouts of the node
                    break;
                if ( Gia_ObjIsAnd(pFanout) && // internal node
                    !Gia_ObjIsTravIdCurrent(p, pFanout) && // not in the window
                     Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin0(pFanout)) && // but fanins are
                     Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin1(pFanout)) )  // in the window
                {
                    // add fanout to the window and to the levelized structure
                    Gia_ObjSetTravIdCurrent( p, pFanout );
                    Vec_WecPush( vLevels, Gia_ObjLevel(p, pFanout), Gia_ObjId(p, pFanout) );
                    Vec_IntPush( vWin, Gia_ObjId(p, pFanout) );
                    Vec_IntPushUniqueOrder( vUsed, Gia_ObjLevel(p, pFanout) );
                }
            }
        Vec_IntClear( vLevel );
    }
    Vec_IntSort( vWin, 0 );
    Vec_IntFree( vUsed );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_WinCreateFromCut_rec()

void Gia_WinCreateFromCut_rec	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vWin )

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

Synopsis [Grow window for the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 982 of file giaResub2.c.

{
    Gia_Obj_t * pObj;
    if ( Gia_ObjIsTravIdCurrentId(p, iObj) )
        return;
    Gia_ObjSetTravIdCurrentId(p, iObj);
    pObj = Gia_ManObj( p, iObj );
    assert( Gia_ObjIsAnd(pObj) );
    Gia_WinCreateFromCut_rec( p, Gia_ObjFaninId0(pObj, iObj), vWin );
    Gia_WinCreateFromCut_rec( p, Gia_ObjFaninId1(pObj, iObj), vWin );
    Vec_IntPush( vWin, iObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_WinNodeHasUnmarkedFanouts()

int Gia_WinNodeHasUnmarkedFanouts	(	Gia_Man_t *	p,
		int	iPivot )

Definition at line 654 of file giaResub2.c.

{
    int f, iFan;
    Gia_ObjForEachFanoutStaticId( p, iPivot, iFan, f )
        if ( !Gia_ObjIsTravIdCurrentId(p, iFan) )
            return 1;
    return 0;
}

Here is the caller graph for this function:

Gia_WinTryAddingNode()

int Gia_WinTryAddingNode	(	Gia_Man_t *	p,
		int	iPivot,
		int	iPivot2,
		Vec_Wec_t *	vLevels,
		Vec_Int_t *	vNodes )

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

Synopsis [Creating a window with support composed of primary inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 568 of file giaResub2.c.

{
    Vec_Int_t * vLevel; 
    Gia_Obj_t * pObj, * pFanout;
    int k, i, f, Count = 0;
    // precondition:  the levelized structure is empty
    assert( Vec_WecSizeSize(vLevels) == 0 );
    // precondition:  the new object to be added (iPivot) is not in the window
    assert( !Gia_ObjIsTravIdCurrentId(p, iPivot) );
    // add the object to the window and to the levelized structure
    Gia_ObjSetTravIdCurrentId( p, iPivot );
    Vec_WecPush( vLevels, Gia_ObjLevelId(p, iPivot), iPivot );
    // the same about the second node if it is given
    if ( iPivot2 != -1 )
    {
        // precondition:  the new object to be added (iPivot2) is not in the window
        assert( !Gia_ObjIsTravIdCurrentId(p, iPivot2) );
        // add the object to the window and to the levelized structure
        Gia_ObjSetTravIdCurrentId( p, iPivot2 );
        Vec_WecPush( vLevels, Gia_ObjLevelId(p, iPivot2), iPivot2 );
    }
    // iterate through all objects and explore their fanouts
    Vec_WecForEachLevel( vLevels, vLevel, k )
        Gia_ManForEachObjVec( vLevel, p, pObj, i )
            Gia_ObjForEachFanoutStatic( p, pObj, pFanout, f )
            {
                if ( f == 5 ) // explore first 5 fanouts of the node
                    break;
                if ( Gia_ObjIsAnd(pFanout) && // internal node
                    !Gia_ObjIsTravIdCurrent(p, pFanout) && // not in the window
                     Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin0(pFanout)) && // but fanins are
                     Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin1(pFanout)) )  // in the window
                {
                    // add fanout to the window and to the levelized structure
                    Gia_ObjSetTravIdCurrent( p, pFanout );
                    Vec_WecPush( vLevels, Gia_ObjLevel(p, pFanout), Gia_ObjId(p, pFanout) );
                    // count the number of nodes in the structure
                    Count++;
                }
            }
    // iterate through the nodes in the levelized structure
    Vec_WecForEachLevel( vLevels, vLevel, k )
    {
        Gia_ManForEachObjVec( vLevel, p, pObj, i )
            if ( vNodes == NULL ) // it was a test run - unmark the node
                Gia_ObjSetTravIdPrevious( p, pObj );
            else // it was a real run - permanently add to the node to the window
                Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
        // clean the levelized structure
        Vec_IntClear( vLevel );
    }
    // return the number of nodes to be added
    return Count;
}

Here is the caller graph for this function: