giaSplit.c File Reference

#include "gia.h"
#include "misc/extra/extra.h"

Include dependency graph for giaSplit.c:

Go to the source code of this file.

Classes
struct	Spl_Man_t_

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Spl_Man_t_	Spl_Man_t
	DECLARATIONS ///.

Functions
Vec_Wec_t *	Spl_ManToWecMapping (Gia_Man_t *p)
	FUNCTION DEFINITIONS ///.
Vec_Int_t *	Spl_ManFromWecMapping (Gia_Man_t *p, Vec_Wec_t *vMap)
Spl_Man_t *	Spl_ManAlloc (Gia_Man_t *pGia, int Limit, int fReverse)
void	Spl_ManStop (Spl_Man_t *p)
void	Spl_ManWinFindLeavesRoots (Spl_Man_t *p)
void	Spl_ManLutFanouts_rec (Gia_Man_t *p, int iObj, Vec_Int_t *vFanouts, Vec_Bit_t *vMarksNo, Vec_Bit_t *vMarksCIO)
int	Spl_ManLutFanouts (Gia_Man_t *p, int iObj, Vec_Int_t *vFanouts, Vec_Bit_t *vMarksNo, Vec_Bit_t *vMarksCIO)
int	Spl_ManCountMarkedFanins (Gia_Man_t *p, int iObj, Vec_Bit_t *vMarks)
int	Spl_ManFindGoodCand (Spl_Man_t *p)
int	Spl_ManFindOne (Spl_Man_t *p)
int	Spl_ManLutMffcSize (Gia_Man_t *p, int iObj, Vec_Int_t *vTemp, Vec_Bit_t *vMarksAnd)
void	Spl_ManAddNode (Spl_Man_t *p, int iPivot, Vec_Int_t *vCands)
int	Spl_ManComputeOne (Spl_Man_t *p, int iPivot)
int	Gia_ManComputeOneWin (Gia_Man_t *pGia, int iPivot, Vec_Int_t **pvRoots, Vec_Int_t **pvNodes, Vec_Int_t **pvLeaves, Vec_Int_t **pvAnds)
void	Gia_ManComputeOneWinStart (Gia_Man_t *pGia, int nAnds, int fReverse)
void	Spl_ManComputeOneTest (Gia_Man_t *pGia)

Typedef Documentation

Spl_Man_t

typedef typedefABC_NAMESPACE_IMPL_START struct Spl_Man_t_ Spl_Man_t

DECLARATIONS ///.

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

FileName [giaSplit.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Structural AIG splitting.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 31 of file giaSplit.c.

Function Documentation

Gia_ManComputeOneWin()

int Gia_ManComputeOneWin	(	Gia_Man_t *	pGia,
		int	iPivot,
		Vec_Int_t **	pvRoots,
		Vec_Int_t **	pvNodes,
		Vec_Int_t **	pvLeaves,
		Vec_Int_t **	pvAnds )

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

Synopsis [External procedures.]

Description []

SideEffects []

SeeAlso []

Definition at line 516 of file giaSplit.c.

{
    Spl_Man_t * p = (Spl_Man_t *)pGia->pSatlutWinman;
    assert( p != NULL );
    if ( iPivot == -1 )
    {
        Spl_ManStop( p );
        pGia->pSatlutWinman = NULL;
        return 0;
    }
    if ( !Spl_ManComputeOne( p, iPivot ) )
    {
        *pvRoots  = NULL;
        *pvNodes  = NULL;
        *pvLeaves = NULL;
        *pvAnds   = NULL;
        return 0;
    }
    *pvRoots  = p->vRoots;
    *pvNodes  = p->vNodes;
    *pvLeaves = p->vLeaves;
    *pvAnds   = p->vAnds;
    // Vec_IntPrint( p->vNodes );
    return Vec_IntSize(p->vAnds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManComputeOneWinStart()

void Gia_ManComputeOneWinStart	(	Gia_Man_t *	pGia,
		int	nAnds,
		int	fReverse )

Definition at line 541 of file giaSplit.c.

{
    assert( pGia->pSatlutWinman == NULL );
    pGia->pSatlutWinman = Spl_ManAlloc( pGia, nAnds, fReverse );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManAddNode()

void Spl_ManAddNode	(	Spl_Man_t *	p,
		int	iPivot,
		Vec_Int_t *	vCands )

Definition at line 452 of file giaSplit.c.

{
    int i, iObj;
    Vec_IntPush( p->vNodes, iPivot );
    Vec_BitWriteEntry( p->vMarksNo, iPivot, 1 );
    Vec_IntAppend( p->vAnds, vCands );
    Vec_IntForEachEntry( vCands, iObj, i )
        Vec_BitWriteEntry( p->vMarksAnd, iObj, 1 );
}

Here is the caller graph for this function:

Spl_ManAlloc()

Spl_Man_t * Spl_ManAlloc	(	Gia_Man_t *	pGia,
		int	Limit,
		int	fReverse )

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

Synopsis [Creating manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 110 of file giaSplit.c.

{
    int i, iObj;
    Spl_Man_t * p = ABC_CALLOC( Spl_Man_t, 1 );
    p->pGia       = pGia;
    p->Limit      = Limit;
    p->fReverse   = fReverse;
    // intermediate
    p->vMarksCIO  = Vec_BitStart( Gia_ManObjNum(pGia) );
    p->vMarksIn   = Vec_BitStart( Gia_ManObjNum(pGia) );
    p->vMarksNo   = Vec_BitStart( Gia_ManObjNum(pGia) );
    p->vMarksAnd  = Vec_BitStart( Gia_ManObjNum(pGia) );
    p->vRoots     = Vec_IntAlloc( 100 );
    p->vNodes     = Vec_IntAlloc( 100 );
    p->vLeaves    = Vec_IntAlloc( 100 );
    p->vAnds      = Vec_IntAlloc( 100 );
    // temporary 
    p->vFanouts   = Vec_IntAlloc( 100 );
    p->vCands     = Vec_IntAlloc( 100 );
    p->vInputs    = Vec_IntAlloc( 100 );
    // mark CIs/COs
    Vec_BitWriteEntry( p->vMarksCIO, 0, 1 );
    Gia_ManForEachCiId( pGia, iObj, i )
        Vec_BitWriteEntry( p->vMarksCIO, iObj, 1 );
    Gia_ManForEachCoId( pGia, iObj, i )
        Vec_BitWriteEntry( p->vMarksCIO, iObj, 1 );
    // mapping
    ABC_FREE( pGia->pRefs );
    Gia_ManCreateRefs( pGia );
    Gia_ManSetLutRefs( pGia );
    assert( Gia_ManHasMapping(pGia) );
    assert( !Gia_ManHasMapping2(pGia) );
    pGia->vMapping2 = Spl_ManToWecMapping( pGia );
    Vec_IntFreeP( &pGia->vMapping );
    // fanout
    Gia_ManStaticFanoutStart( pGia );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManComputeOne()

int Spl_ManComputeOne	(	Spl_Man_t *	p,
		int	iPivot )

Definition at line 461 of file giaSplit.c.

{
    int CountAdd, iObj, i;
    assert( Gia_ObjIsLut2(p->pGia, iPivot) );
//Gia_ManPrintCone2( p->pGia, Gia_ManObj(p->pGia, iPivot) );
    // assume it was previously filled in
    Vec_IntForEachEntry( p->vNodes, iObj, i )
        Vec_BitWriteEntry( p->vMarksNo, iObj, 0 );
    Vec_IntForEachEntry( p->vAnds, iObj, i )
        Vec_BitWriteEntry( p->vMarksAnd, iObj, 0 );
    // double check that it is empty
    //Gia_ManForEachLut2( p->pGia, iObj )
    //    assert( !Vec_BitEntry(p->vMarksNo, iObj) );
    //Gia_ManForEachLut2( p->pGia, iObj )
    //    assert( !Vec_BitEntry(p->vMarksAnd, iObj) );
    // clean arrays
    Vec_IntClear( p->vNodes );
    Vec_IntClear( p->vAnds );
    // add root node
    Spl_ManLutMffcSize( p->pGia, iPivot, p->vCands, p->vMarksAnd );
    Spl_ManAddNode( p, iPivot, p->vCands );
    if ( Vec_IntSize(p->vAnds) > p->Limit )
        return 0;
    //printf( "%d ", iPivot );
    // add one node at a time
    while ( (iObj = Spl_ManFindOne(p)) )
    {
        assert( Gia_ObjIsLut2(p->pGia, iObj) );
        assert( !Vec_BitEntry(p->vMarksNo, iObj) );
        CountAdd = Spl_ManLutMffcSize( p->pGia, iObj, p->vCands, p->vMarksAnd );
        if ( Vec_IntSize(p->vAnds) + CountAdd > p->Limit )
            break;
        Spl_ManAddNode( p, iObj, p->vCands );
        //printf( "+%d ", iObj );
    }
    //printf( "\n" );
    Vec_IntSort( p->vNodes, 0 );
    Vec_IntSort( p->vAnds, 0 );
    Spl_ManWinFindLeavesRoots( p );
    Vec_IntSort( p->vLeaves, 0 );
    Vec_IntSort( p->vRoots, 0 );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManComputeOneTest()

void Spl_ManComputeOneTest

(

Gia_Man_t *

pGia

)

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

Synopsis [Testing procedure.]

Description []

SideEffects []

SeeAlso []

Definition at line 558 of file giaSplit.c.

{
    int iLut, Count;
    Gia_ManComputeOneWinStart( pGia, 64, 0 );
    Gia_ManForEachLut2( pGia, iLut )
    {
        Vec_Int_t * vRoots, * vNodes, * vLeaves, * vAnds;
        Count = Gia_ManComputeOneWin( pGia, iLut, &vRoots, &vNodes, &vLeaves, &vAnds );
        printf( "Obj = %6d : Leaf = %2d.  Node = %2d.  Root = %2d.    AND = %3d.\n", 
            iLut, Vec_IntSize(vLeaves), Vec_IntSize(vNodes), Vec_IntSize(vRoots), Count ); 
    }
    Gia_ManComputeOneWin( pGia, -1, NULL, NULL, NULL, NULL );
}

Here is the call graph for this function:

Spl_ManCountMarkedFanins()

int Spl_ManCountMarkedFanins	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Bit_t *	vMarks )

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

Synopsis [Returns the number of fanins beloning to the set.]

Description []

SideEffects []

SeeAlso []

Definition at line 293 of file giaSplit.c.

{
    int i, iFan, Count = 0;
    Vec_Int_t * vFanins = Gia_ObjLutFanins2(p, iObj);
    Vec_IntForEachEntry( vFanins, iFan, i )
        if ( Vec_BitEntry(vMarks, iFan) )
            Count++;
    return Count;
}

Here is the caller graph for this function:

Spl_ManFindGoodCand()

int Spl_ManFindGoodCand

(

Spl_Man_t *

p

)

Definition at line 302 of file giaSplit.c.

{
    int i, iObj;
    int Res = 0, InCount, InCountMax = -1; 
    // mark leaves
    Vec_IntForEachEntry( p->vInputs, iObj, i )
        Vec_BitWriteEntry( p->vMarksIn, iObj, 1 );
    // find candidate with maximum input overlap
    Vec_IntForEachEntry( p->vCands, iObj, i )
    {
        InCount = Spl_ManCountMarkedFanins( p->pGia, iObj, p->vMarksIn );
        if ( InCountMax < InCount )
        {
            InCountMax = InCount;
            Res = iObj;
        }
    }
    // unmark leaves
    Vec_IntForEachEntry( p->vInputs, iObj, i )
        Vec_BitWriteEntry( p->vMarksIn, iObj, 0 );
    return Res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManFindOne()

int Spl_ManFindOne

(

Spl_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 336 of file giaSplit.c.

{
    Vec_Int_t * vVec;
    int nFanouts, iObj, iFan, i, k;
    int Res = 0; 
 
    // deref
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
        Vec_IntForEachEntry( vVec, iFan, k )
            Gia_ObjLutRefDecId( p->pGia, iFan );
 
    // collect external nodes
    if ( p->fReverse && (Vec_IntSize(p->vNodes) & 1) )
    {
        Vec_IntForEachEntry( p->vNodes, iObj, i )
        {
            if ( Gia_ObjLutRefNumId(p->pGia, iObj) == 0 )
                continue;
            assert( Gia_ObjLutRefNumId(p->pGia, iObj) > 0 );
            if ( Gia_ObjLutRefNumId(p->pGia, iObj) >= 5 )  // skip nodes with high fanout!
                continue;
            nFanouts = Spl_ManLutFanouts( p->pGia, iObj, p->vFanouts, p->vMarksNo, p->vMarksCIO );
            if ( Gia_ObjLutRefNumId(p->pGia, iObj) == 1 && nFanouts == 1 )
            {
                Res = Vec_IntEntry(p->vFanouts, 0);
                goto finish;
            }
            //Vec_IntAppend( p->vCands, p->vFanouts );
        }
    }
 
    // consider LUT inputs - get one that has no refs
    Vec_IntClear( p->vCands );
    Vec_IntClear( p->vInputs );
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
        Vec_IntForEachEntry( vVec, iFan, k )
            if ( !Vec_BitEntry(p->vMarksNo, iFan) && !Vec_BitEntry(p->vMarksCIO, iFan) && !Gia_ObjLutRefNumId(p->pGia, iFan) )
            {
                Vec_IntPush( p->vCands, iFan );
                Vec_IntPush( p->vInputs, iFan );
            }
    Res = Spl_ManFindGoodCand( p );
    if ( Res )
        goto finish;
 
    // collect candidates
    Vec_IntClear( p->vCands );
    Vec_IntClear( p->vInputs );
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
        Vec_IntForEachEntry( vVec, iFan, k )
            if ( !Vec_BitEntry(p->vMarksNo, iFan) && !Vec_BitEntry(p->vMarksCIO, iFan) )
            {
                Vec_IntPush( p->vCands, iFan );
                Vec_IntPush( p->vInputs, iFan );
            }
 
    // all inputs have refs - collect external nodes
    Vec_IntForEachEntry( p->vNodes, iObj, i )
    {
        if ( Gia_ObjLutRefNumId(p->pGia, iObj) == 0 )
            continue;
        assert( Gia_ObjLutRefNumId(p->pGia, iObj) > 0 );
        if ( Gia_ObjLutRefNumId(p->pGia, iObj) >= 5 )  // skip nodes with high fanout!
            continue;
        nFanouts = Spl_ManLutFanouts( p->pGia, iObj, p->vFanouts, p->vMarksNo, p->vMarksCIO );
        if ( Gia_ObjLutRefNumId(p->pGia, iObj) == 1 && nFanouts == 1 )
        {
            Res = Vec_IntEntry(p->vFanouts, 0);
            goto finish;
        }
        Vec_IntAppend( p->vCands, p->vFanouts );
    }
 
    // choose among not-so-good ones
    Res = Spl_ManFindGoodCand( p );
    if ( Res )
        goto finish;
 
    // get the first candidate
    if ( Res == 0 && Vec_IntSize(p->vCands) > 0 )
        Res = Vec_IntEntry( p->vCands, 0 );
 
finish:
    // ref
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
        Vec_IntForEachEntry( vVec, iFan, k )
            Gia_ObjLutRefIncId( p->pGia, iFan );
    return Res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManFromWecMapping()

Vec_Int_t * Spl_ManFromWecMapping	(	Gia_Man_t *	p,
		Vec_Wec_t *	vMap )

Definition at line 79 of file giaSplit.c.

{
    Vec_Int_t * vMapping, * vVec; int i, k, Obj;
    assert( Gia_ManHasMapping2(p) );
    vMapping = Vec_IntAlloc( Gia_ManObjNum(p) + Vec_WecSizeSize(vMap) + 2*Vec_WecSizeUsed(vMap) );
    Vec_IntFill( vMapping, Gia_ManObjNum(p), 0 );
    Vec_WecForEachLevel( vMap, vVec, i )
        if ( Vec_IntSize(vVec) > 0 )
        {
            Vec_IntWriteEntry( vMapping, i, Vec_IntSize(vMapping) );
            Vec_IntPush( vMapping, Vec_IntSize(vVec) );
            Vec_IntForEachEntry( vVec, Obj, k )
                Vec_IntPush( vMapping, Obj );
            Vec_IntPush( vMapping, i );
        }
    assert( Vec_IntSize(vMapping) < 16 || Vec_IntSize(vMapping) == Vec_IntCap(vMapping) );
    return vMapping;
}

Here is the caller graph for this function:

Spl_ManLutFanouts()

int Spl_ManLutFanouts	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vFanouts,
		Vec_Bit_t *	vMarksNo,
		Vec_Bit_t *	vMarksCIO )

Definition at line 268 of file giaSplit.c.

{
    int i, iFanout;
    assert( Gia_ObjIsLut2(p, iObj) );
    Vec_IntClear( vFanouts );
    Gia_ObjForEachFanoutStaticId( p, iObj, iFanout, i )
        Spl_ManLutFanouts_rec( p, iFanout, vFanouts, vMarksNo, vMarksCIO );
    // clean up
    Vec_IntForEachEntry( vFanouts, iFanout, i )
        Vec_BitWriteEntry( vMarksCIO, iFanout, 0 );
    return Vec_IntSize(vFanouts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManLutFanouts_rec()

void Spl_ManLutFanouts_rec	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vFanouts,
		Vec_Bit_t *	vMarksNo,
		Vec_Bit_t *	vMarksCIO )

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

Synopsis [Computes LUTs that are fanouts of the node outside of the cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 254 of file giaSplit.c.

{
    int iFanout, i;
    if ( Vec_BitEntry(vMarksNo, iObj) || Vec_BitEntry(vMarksCIO, iObj) )
        return;
    if ( Gia_ObjIsLut2(p, iObj) )
    {
        Vec_BitWriteEntry( vMarksCIO, iObj, 1 );
        Vec_IntPush( vFanouts, iObj );
        return;
    }
    Gia_ObjForEachFanoutStaticId( p, iObj, iFanout, i )
        Spl_ManLutFanouts_rec( p, iFanout, vFanouts, vMarksNo, vMarksCIO );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManLutMffcSize()

int Spl_ManLutMffcSize	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vTemp,
		Vec_Bit_t *	vMarksAnd )

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

Synopsis [Computing window for one pivot node.]

Description []

SideEffects []

SeeAlso []

Definition at line 439 of file giaSplit.c.

{
    int iTemp, i, k = 0;
    assert( Gia_ObjIsLut2(p, iObj) );
//Vec_IntPrint( Gia_ObjLutFanins2(p, iObj) );
    Gia_ManIncrementTravId( p );
    Gia_ManCollectAnds( p, &iObj, 1, vTemp, Gia_ObjLutFanins2(p, iObj) );
    Vec_IntForEachEntry( vTemp, iTemp, i )
        if ( !Vec_BitEntry(vMarksAnd, iTemp) )
            Vec_IntWriteEntry( vTemp, k++, iTemp );
    Vec_IntShrink( vTemp, k );
    return k;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManStop()

void Spl_ManStop

(

Spl_Man_t *

p

)

Definition at line 148 of file giaSplit.c.

{
    // fanout
    Gia_ManStaticFanoutStop( p->pGia );
    // mapping
    assert( !Gia_ManHasMapping(p->pGia) );
    assert( Gia_ManHasMapping2(p->pGia) );
    p->pGia->vMapping = Spl_ManFromWecMapping( p->pGia, p->pGia->vMapping2 );
    Vec_WecFreeP( &p->pGia->vMapping2 );
    // intermediate
    Vec_BitFree( p->vMarksCIO );
    Vec_BitFree( p->vMarksIn );
    Vec_BitFree( p->vMarksNo );
    Vec_BitFree( p->vMarksAnd );
    Vec_IntFree( p->vRoots );
    Vec_IntFree( p->vNodes );
    Vec_IntFree( p->vLeaves );
    Vec_IntFree( p->vAnds );
    // temporary 
    Vec_IntFree( p->vFanouts );
    Vec_IntFree( p->vCands );
    Vec_IntFree( p->vInputs );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Spl_ManToWecMapping()

Vec_Wec_t * Spl_ManToWecMapping

(

Gia_Man_t *

p

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Transforming to the internal LUT representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 69 of file giaSplit.c.

{
    Vec_Wec_t * vMapping = Vec_WecStart( Gia_ManObjNum(p) );
    int Obj, Fanin, k;
    assert( Gia_ManHasMapping(p) );
    Gia_ManForEachLut( p, Obj )
        Gia_LutForEachFanin( p, Obj, Fanin, k )
            Vec_WecPush( vMapping, Obj, Fanin );
    return vMapping;
}

Here is the caller graph for this function:

Spl_ManWinFindLeavesRoots()

void Spl_ManWinFindLeavesRoots

(

Spl_Man_t *

p

)

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

Synopsis [Takes Nodes and Marks. Returns Leaves and Roots.]

Description []

SideEffects []

SeeAlso []

Definition at line 184 of file giaSplit.c.

{
    Vec_Int_t * vVec;
    int iObj, iFan, i, k;
    // collect leaves
/*
    Vec_IntClear( p->vLeaves );
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
    {
        assert( Vec_BitEntry(p->vMarksNo, iObj) );
        Vec_IntForEachEntry( vVec, iFan, k )
            if ( !Vec_BitEntry(p->vMarksNo, iFan) )
            {
                Vec_BitWriteEntry(p->vMarksNo, iFan, 1);
                Vec_IntPush( p->vLeaves, iFan );
            }
    }
    Vec_IntForEachEntry( p->vLeaves, iFan, i )
        Vec_BitWriteEntry(p->vMarksNo, iFan, 0);
*/
    Vec_IntClear( p->vLeaves );
    Vec_IntForEachEntry( p->vAnds, iObj, i )
    {
        Gia_Obj_t * pObj = Gia_ManObj( p->pGia, iObj );
        assert( Vec_BitEntry(p->vMarksAnd, iObj) );
        iFan = Gia_ObjFaninId0( pObj, iObj );
        if ( !Vec_BitEntry(p->vMarksAnd, iFan) )
        {
            assert( Gia_ObjIsLut2(p->pGia, iFan) || Vec_BitEntry(p->vMarksCIO, iFan) );
            Vec_BitWriteEntry(p->vMarksAnd, iFan, 1);
            Vec_IntPush( p->vLeaves, iFan );
        }
        iFan = Gia_ObjFaninId1( pObj, iObj );
        if ( !Vec_BitEntry(p->vMarksAnd, iFan) )
        {
            assert( Gia_ObjIsLut2(p->pGia, iFan) || Vec_BitEntry(p->vMarksCIO, iFan) );
            Vec_BitWriteEntry(p->vMarksAnd, iFan, 1);
            Vec_IntPush( p->vLeaves, iFan );
        }
    }
    Vec_IntForEachEntry( p->vLeaves, iFan, i )
        Vec_BitWriteEntry(p->vMarksAnd, iFan, 0);
 
    // collect roots
    Vec_IntClear( p->vRoots );
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
        Vec_IntForEachEntry( vVec, iFan, k )
            Gia_ObjLutRefDecId( p->pGia, iFan );
    Vec_IntForEachEntry( p->vAnds, iObj, i )
        if ( Gia_ObjLutRefNumId(p->pGia, iObj) )
            Vec_IntPush( p->vRoots, iObj );
    Gia_ManForEachLut2Vec( p->vNodes, p->pGia, vVec, iObj, i )
        Vec_IntForEachEntry( vVec, iFan, k )
            Gia_ObjLutRefIncId( p->pGia, iFan );
}

Here is the caller graph for this function: