#include "gia.h"
#include "misc/tim/tim.h"
#include "misc/vec/vecSet.h"
#include "misc/vec/vecMem.h"
#include "misc/util/utilTruth.h"

Include dependency graph for giaLf.c:

Go to the source code of this file.

Classes
struct	Lf_Cut_t_

struct	Lf_Plc_t_

struct	Lf_Bst_t_

struct	Lf_Mem_t_

struct	Lf_Man_t_

Macros
#define	LF_LEAF_MAX 13
	DECLARATIONS ///.

#define	LF_CUT_MAX 32

#define	LF_LOG_PAGE 12

#define	LF_NO_LEAF 255

#define	LF_CUT_WORDS (4+LF_LEAF_MAX/2)

#define	LF_TT_WORDS ((LF_LEAF_MAX > 6) ? 1 << (LF_LEAF_MAX-6) : 1)

#define	LF_EPSILON 0.005

#define	Lf_CutSetForEachCut(nWords, pCutSet, pCut, i, nCuts)

#define	Lf_CutForEachVar(pCut, Var, i)

Typedefs
typedef struct Lf_Cut_t_	Lf_Cut_t

typedef struct Lf_Plc_t_	Lf_Plc_t

typedef struct Lf_Bst_t_	Lf_Bst_t

typedef struct Lf_Mem_t_	Lf_Mem_t

typedef struct Lf_Man_t_	Lf_Man_t

Functions
int	Kit_TruthToGia (Gia_Man_t pMan, unsigned pTruth, int nVars, Vec_Int_t vMemory, Vec_Int_t vLeaves, int fHash)
	DECLARATIONS ///.

int	Lf_ObjArrival_rec (Lf_Man_t p, Gia_Obj_t pDriver)

int	Lf_ObjCoArrival2_rec (Lf_Man_t p, Gia_Obj_t pDriver)

int	Lf_ManComputeCrossCut (Gia_Man_t *p)

int	Lf_ManTtIsMux (word t)

void	Lf_ManAnalyzeCoDrivers (Gia_Man_t p, int pnDrivers, int *pnInverts)

void	Lf_ManComputeSwitching (Gia_Man_t p, Vec_Flt_t vSwitches)

float	Lf_CutRef_rec (Lf_Man_t p, Lf_Cut_t pCut)

float	Lf_CutDeref_rec (Lf_Man_t p, Lf_Cut_t pCut)

void	Lf_ObjMergeOrder (Lf_Man_t *p, int iObj)

void	Lf_ManSetFlowRefs (Gia_Man_t p, Vec_Flt_t vRefs, Vec_Int_t *vOffsets)

void	Lf_ManSetCutRefs (Lf_Man_t *p)

void	Lf_ManSetMapRefsOne (Lf_Man_t *p, int iObj)

int	Lf_ManSetMapRefs (Lf_Man_t *p)

void	Lf_ManCountMapRefsOne (Lf_Man_t *p, int iObj)

void	Lf_ManCountMapRefs (Lf_Man_t *p)

Gia_Man_t *	Lf_ManDeriveMapping (Lf_Man_t *p)

Gia_Man_t *	Lf_ManDeriveMappingCoarse (Lf_Man_t *p)

Gia_Man_t *	Lf_ManDeriveMappingGia (Lf_Man_t *p)

Lf_Man_t *	Lf_ManAlloc (Gia_Man_t pGia, Jf_Par_t pPars)

void	Lf_ManFree (Lf_Man_t *p)

void	Lf_ManSetDefaultPars (Jf_Par_t *pPars)

void	Lf_ManPrintStats (Lf_Man_t p, char pTitle)

void	Lf_ManPrintInit (Lf_Man_t *p)

void	Lf_ManPrintQuit (Lf_Man_t p, Gia_Man_t pNew)

void	Lf_ManComputeMapping (Lf_Man_t *p)

Gia_Man_t *	Lf_ManPerformMappingInt (Gia_Man_t pGia, Jf_Par_t pPars)

Gia_Man_t *	Lf_ManPerformMapping (Gia_Man_t p, Jf_Par_t pPars)

Gia_Man_t *	Gia_ManPerformLfMapping (Gia_Man_t p, Jf_Par_t pPars, int fNormalized)

Macro Definition Documentation

◆ LF_CUT_MAX

#define LF_CUT_MAX 32

Definition at line 34 of file giaLf.c.

◆ LF_CUT_WORDS

#define LF_CUT_WORDS (4+LF_LEAF_MAX/2)

Definition at line 37 of file giaLf.c.

◆ Lf_CutForEachVar

#define Lf_CutForEachVar	(	pCut,
		Var,
		i )

Value:

for ( i = 0; i < (int)pCut->nLeaves && (Var = pCut->pLeaves[i]); i++ ) if ( Lf_ObjOff(p, Var) < 0 ) {} else

p

Cube * p

Definition exorList.c:222

Var

int Var

Definition exorList.c:228

Definition at line 135 of file giaLf.c.

◆ Lf_CutSetForEachCut

#define Lf_CutSetForEachCut	(	nWords,
		pCutSet,
		pCut,
		i,
		nCuts )

Value:

for ( i = 0, pCut = pCutSet; i < nCuts; pCut = Lf_CutNext(pCut, nWords), i++ )

nWords

int nWords

Definition abcNpn.c:127

Definition at line 134 of file giaLf.c.

◆ LF_EPSILON

#define LF_EPSILON 0.005

Definition at line 39 of file giaLf.c.

◆ LF_LEAF_MAX

#define LF_LEAF_MAX 13

DECLARATIONS ///.

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

FileName [giaLf.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Cut computation.]

Author [Alan Mishchenko]`

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 33 of file giaLf.c.

◆ LF_LOG_PAGE

#define LF_LOG_PAGE 12

Definition at line 35 of file giaLf.c.

◆ LF_NO_LEAF

#define LF_NO_LEAF 255

Definition at line 36 of file giaLf.c.

◆ LF_TT_WORDS

#define LF_TT_WORDS ((LF_LEAF_MAX > 6) ? 1 << (LF_LEAF_MAX-6) : 1)

Definition at line 38 of file giaLf.c.

Typedef Documentation

◆ Lf_Bst_t

typedef struct Lf_Bst_t_ Lf_Bst_t

Definition at line 60 of file giaLf.c.

◆ Lf_Cut_t

typedef struct Lf_Cut_t_ Lf_Cut_t

Definition at line 41 of file giaLf.c.

◆ Lf_Man_t

typedef struct Lf_Man_t_ Lf_Man_t

Definition at line 77 of file giaLf.c.

◆ Lf_Mem_t

typedef struct Lf_Mem_t_ Lf_Mem_t

Definition at line 67 of file giaLf.c.

◆ Lf_Plc_t

typedef struct Lf_Plc_t_ Lf_Plc_t

Definition at line 54 of file giaLf.c.

Function Documentation

◆ Gia_ManPerformLfMapping()

Gia_Man_t * Gia_ManPerformLfMapping	(	Gia_Man_t *	p,
		Jf_Par_t *	pPars,
		int	fNormalized )

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

Synopsis [Interface of LUT mapping package.]

Description []

SideEffects []

SeeAlso []

Definition at line 2292 of file giaLf.c.

{
    Gia_Man_t * pNew;
    assert( !pPars->fCutGroup || pPars->nLutSize == 9 || pPars->nLutSize == 11 || pPars->nLutSize == 13 );
    // reconstruct GIA according to the hierarchy manager
    assert( pPars->pTimesArr == NULL );
    assert( pPars->pTimesReq == NULL );
    if ( p->pManTime )
    {
        if ( fNormalized )
        {
            pNew = Gia_ManDupUnnormalize( p );
            if ( pNew == NULL )
                return NULL;
            Gia_ManTransferTiming( pNew, p );
            p = pNew;
            // set arrival and required times
            pPars->pTimesArr = Tim_ManGetArrTimes( (Tim_Man_t *)p->pManTime );
            pPars->pTimesReq = Tim_ManGetReqTimes( (Tim_Man_t *)p->pManTime );
        }
        else
            p = Gia_ManDup( p );
    }
    else 
        p = Gia_ManDup( p );
    // perform mapping
    pNew = Lf_ManPerformMappingInt( p, pPars );
    if ( pNew != p )
    {
        // transfer name
        ABC_FREE( pNew->pName );
        ABC_FREE( pNew->pSpec );
        pNew->pName = Abc_UtilStrsav( p->pName );
        pNew->pSpec = Abc_UtilStrsav( p->pSpec );
        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
        // return the original (unmodified by the mapper) timing manager
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p );
    }
    // normalize and transfer mapping
    pNew = Gia_ManDupNormalize( p = pNew, 0 );
    Gia_ManTransferMapping( pNew, p );
//    Gia_ManTransferPacking( pNew, p );
    Gia_ManTransferTiming( pNew, p );
    Gia_ManStop( p );
    return pNew;
}

Here is the call graph for this function:

◆ Kit_TruthToGia()

int Kit_TruthToGia	(	Gia_Man_t *	pMan,
		unsigned *	pTruth,
		int	nVars,
		Vec_Int_t *	vMemory,
		Vec_Int_t *	vLeaves,
		int	fHash )

extern

DECLARATIONS ///.

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

FileName [giaMap.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Manipulation of mapping associated with the AIG.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 80 of file kitHop.c.

{
    int iLit;
    Kit_Graph_t * pGraph;
    // transform truth table into the decomposition tree
    if ( vMemory == NULL )
    {
        vMemory = Vec_IntAlloc( 0 );
        pGraph = Kit_TruthToGraph( pTruth, nVars, vMemory );
        Vec_IntFree( vMemory );
    }
    else
        pGraph = Kit_TruthToGraph( pTruth, nVars, vMemory );
    if ( pGraph == NULL )
    {
        printf( "Kit_TruthToGia(): Converting truth table to AIG has failed for function:\n" );
        Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" );
    }
    // derive the AIG for the decomposition tree
    iLit = Kit_GraphToGia( pMan, pGraph, vLeaves, fHash );
    Kit_GraphFree( pGraph );
    return iLit;
}

◆ Lf_CutDeref_rec()

float Lf_CutDeref_rec	(	Lf_Man_t *	p,
		Lf_Cut_t *	pCut )

Definition at line 1085 of file giaLf.c.

{
    word CutTemp[LF_CUT_WORDS] = {0};
    float Count = Lf_CutArea(p, pCut);
    int i, Var; 
    Lf_CutForEachVar( pCut, Var, i )
        if ( !Lf_ObjMapRefDec(p, Var) )
            Count += Lf_CutDeref_rec( p, Lf_ObjCutBestNew(p, Var, (Lf_Cut_t *)CutTemp) );
    return Count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_CutRef_rec()

float Lf_CutRef_rec	(	Lf_Man_t *	p,
		Lf_Cut_t *	pCut )

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

Synopsis [Exact local area.]

Description []

SideEffects []

SeeAlso []

Definition at line 1075 of file giaLf.c.

{
    word CutTemp[LF_CUT_WORDS] = {0};
    float Count = Lf_CutArea(p, pCut);
    int i, Var; 
    Lf_CutForEachVar( pCut, Var, i )
        if ( !Lf_ObjMapRefInc(p, Var) )
            Count += Lf_CutRef_rec( p, Lf_ObjCutBestNew(p, Var, (Lf_Cut_t *)CutTemp) );
    return Count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManAlloc()

Lf_Man_t * Lf_ManAlloc	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1938 of file giaLf.c.

{
    Lf_Man_t * p; int i, k = 0;
    assert( pPars->nCutNum > 1  && pPars->nCutNum <= LF_CUT_MAX );
    assert( pPars->nLutSize > 1 && pPars->nLutSize <= LF_LEAF_MAX );
    ABC_FREE( pGia->pRefs );
    Vec_IntFreeP( &pGia->vMapping );
    Gia_ManCleanValue( pGia );
    if ( Gia_ManHasChoices(pGia) )
        Gia_ManSetPhase(pGia);
    p = ABC_CALLOC( Lf_Man_t, 1 );
    Lf_ManAnalyzeCoDrivers( pGia, &p->nCoDrivers, &p->nInverters );
    if ( pPars->fPower )
        Lf_ManComputeSwitching( pGia, &p->vSwitches );
    p->clkStart  = Abc_Clock();
    p->pGia      = pGia;
    p->pPars     = pPars;
    p->nCutWords = (sizeof(Lf_Cut_t)/sizeof(int) + pPars->nLutSize + 1) >> 1;
    p->nSetWords = p->nCutWords * pPars->nCutNum;
    p->vTtMem    = pPars->fCutMin ? Vec_MemAllocForTT( pPars->nLutSize, 0 ) : NULL;
    if ( pPars->fCutMin && pPars->fUseMux7 )
        Vec_MemAddMuxTT( p->vTtMem, pPars->nLutSize );
    p->pObjBests = ABC_CALLOC( Lf_Bst_t, Gia_ManAndNotBufNum(pGia) );
    Vec_IntGrow( &p->vFreeSets, (1<<14) );
    Vec_PtrGrow( &p->vFreePages, 256 );
    Lf_MemAlloc( &p->vStoreOld, 16, &p->vFreePages, p->nCutWords );
    Lf_MemAlloc( &p->vStoreNew, 16, &p->vFreePages, p->nCutWords );
    Vec_IntFill( &p->vOffsets,  Gia_ManObjNum(pGia), -1 );
    Vec_IntFill( &p->vRequired, Gia_ManObjNum(pGia), ABC_INFINITY );
    Vec_IntFill( &p->vCutSets,  Gia_ManAndNotBufNum(pGia), -1 );
    Vec_FltFill( &p->vFlowRefs, Gia_ManAndNotBufNum(pGia), 0 );
    Vec_IntFill( &p->vMapRefs,  Gia_ManAndNotBufNum(pGia), 0 );
    Vec_IntFill( &p->vCiArrivals, Gia_ManCiNum(pGia), 0 );
    Gia_ManForEachAndId( pGia, i )
        if ( !Gia_ObjIsBuf(Gia_ManObj(pGia, i)) )
            Vec_IntWriteEntry( &p->vOffsets, i, k++ );
    assert( k == Gia_ManAndNotBufNum(pGia) );
    Lf_ManSetFlowRefs( pGia, &p->vFlowRefs, &p->vOffsets );
    if ( pPars->pTimesArr )
        for ( i = 0; i < Gia_ManPiNum(pGia); i++ )
            Vec_IntWriteEntry( &p->vCiArrivals, i, pPars->pTimesArr[i] );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManAnalyzeCoDrivers()

void Lf_ManAnalyzeCoDrivers	(	Gia_Man_t *	p,
		int *	pnDrivers,
		int *	pnInverts )

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

Synopsis [Count the number of unique drivers and invertors.]

Description []

SideEffects []

SeeAlso []

Definition at line 319 of file giaLf.c.

{
    Gia_Obj_t * pObj;
    int i, Entry, nDrivers, nInverts;
    Vec_Int_t * vMarks = Vec_IntStart( Gia_ManObjNum(p) );
    nDrivers = nInverts = 0;
    Gia_ManForEachCo( p, pObj, i )
        *Vec_IntEntryP( vMarks, Gia_ObjFaninId0p(p, pObj) ) |= Gia_ObjFaninC0(pObj) ? 2 : 1;
    Vec_IntForEachEntry( vMarks, Entry, i )
        nDrivers += (int)(Entry != 0), nInverts += (int)(Entry == 3);
    Vec_IntFree( vMarks );
    *pnDrivers = nDrivers;
    *pnInverts = nInverts;
}

Here is the caller graph for this function:

◆ Lf_ManComputeCrossCut()

int Lf_ManComputeCrossCut ( Gia_Man_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 226 of file giaLf.c.

{
    Gia_Obj_t * pObj;
    int i, nCutMax = 0, nCutCur = 0;
    assert( p->pMuxes == NULL );
    Gia_ManForEachObj( p, pObj, i )
        pObj->Value = 0;
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) )
            Gia_ObjFanin0(pObj)->Value++;
        if ( Gia_ObjIsAnd(Gia_ObjFanin1(pObj)) )
            Gia_ObjFanin1(pObj)->Value++;
    }
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( pObj->Value )
            nCutCur++;
        if ( nCutMax < nCutCur )
            nCutMax = nCutCur;
        if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) && --Gia_ObjFanin0(pObj)->Value == 0 )
            nCutCur--;
        if ( Gia_ObjIsAnd(Gia_ObjFanin1(pObj)) && --Gia_ObjFanin1(pObj)->Value == 0 )
            nCutCur--;
    }
    assert( nCutCur == 0 );
    if ( nCutCur )
        printf( "Cutset is not 0\n" );
    Gia_ManForEachObj( p, pObj, i )
        assert( pObj->Value == 0 );
    printf( "CutMax = %d\n", nCutMax );
    return nCutMax;
}

◆ Lf_ManComputeMapping()

void Lf_ManComputeMapping ( Lf_Man_t * p )

Definition at line 2138 of file giaLf.c.

{
    Gia_Obj_t * pObj;
    int i, arrTime;
    assert( p->vStoreNew.iCur == 0 );
    Lf_ManSetCutRefs( p );
    if ( p->pGia->pManTime != NULL )
    {
        assert( !Gia_ManBufNum(p->pGia) );
        Tim_ManIncrementTravId( (Tim_Man_t*)p->pGia->pManTime );
        Gia_ManForEachObj1( p->pGia, pObj, i )
        {
            if ( Gia_ObjIsBuf(pObj) )
                continue;
            if ( Gia_ObjIsAnd(pObj) )
                Lf_ObjMergeOrder( p, i );
            else if ( Gia_ObjIsCi(pObj) )
            {
                arrTime = Tim_ManGetCiArrival( (Tim_Man_t*)p->pGia->pManTime, Gia_ObjCioId(pObj) );
                Lf_ObjSetCiArrival( p, Gia_ObjCioId(pObj), arrTime );
            }
            else if ( Gia_ObjIsCo(pObj) )
            {
                arrTime = Lf_ObjCoArrival( p, Gia_ObjCioId(pObj) );
                Tim_ManSetCoArrival( (Tim_Man_t*)p->pGia->pManTime, Gia_ObjCioId(pObj), arrTime );
            }
            else assert( 0 );
        }
//        Tim_ManPrint( p->pGia->pManTime );
    }
    else
    {
        Gia_ManForEachAnd( p->pGia, pObj, i )
            if ( !Gia_ObjIsBuf(pObj) )
                Lf_ObjMergeOrder( p, i );
    }
    Lf_MemRecycle( &p->vStoreOld );
    ABC_SWAP( Lf_Mem_t, p->vStoreOld, p->vStoreNew );
    if ( p->fUseEla )
        Lf_ManCountMapRefs( p );
    else
        Lf_ManSetMapRefs( p );
    Lf_ManPrintStats( p, (char *)(p->fUseEla ? "Ela  " : (p->Iter ? "Area " : "Delay")) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManComputeSwitching()

void Lf_ManComputeSwitching	(	Gia_Man_t *	p,
		Vec_Flt_t *	vSwitches )

Definition at line 333 of file giaLf.c.

{
//    abctime clk = Abc_Clock();
    Vec_Flt_t * vSwitching = (Vec_Flt_t *)Gia_ManComputeSwitchProbs( p, 48, 16, 0 );
    assert( Vec_FltCap(vSwitches) == 0 );
    *vSwitches = *vSwitching;
    ABC_FREE( vSwitching );
//    Abc_PrintTime( 1, "Computing switching activity", Abc_Clock() - clk );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManCountMapRefs()

void Lf_ManCountMapRefs ( Lf_Man_t * p )

Definition at line 1633 of file giaLf.c.

{
    // compute delay
    Gia_Obj_t * pObj;
    int i, Id, Delay = 0;
    for ( i = 0; i < Gia_ManCoNum(p->pGia); i++ )
        Delay = Abc_MaxInt( Delay, Lf_ObjCoArrival2(p, i) );
    // check delay target
    if ( p->pPars->DelayTarget == -1 && p->pPars->nRelaxRatio )
        p->pPars->DelayTarget = (int)((float)Delay * (100.0 + p->pPars->nRelaxRatio) / 100.0);
    if ( p->pPars->DelayTarget != -1 )
    {
        if ( Delay < p->pPars->DelayTarget + 0.01 )
            Delay = p->pPars->DelayTarget;
        else if ( p->pPars->nRelaxRatio == 0 )
            Abc_Print( 0, "Relaxing user-specified delay target from %d to %d.\n", p->pPars->DelayTarget, Delay );
    }
    p->pPars->Delay = Delay;
    // compute area/edges/required
    p->pPars->Mux7 = p->pPars->Area = p->pPars->Edge = p->Switches = 0;
    Vec_IntFill( &p->vRequired, Gia_ManObjNum(p->pGia), ABC_INFINITY );
    if ( p->pPars->fUseMux7 )
        Gia_ManCleanMark0(p->pGia);
    if ( p->pGia->pManTime != NULL )
    {
        Tim_ManIncrementTravId( (Tim_Man_t*)p->pGia->pManTime );
        if ( p->pPars->fDoAverage )
            for ( i = 0; i < Gia_ManCoNum(p->pGia); i++ )
               Tim_ManSetCoRequired( (Tim_Man_t*)p->pGia->pManTime, i, (int)(Lf_ObjCoArrival(p, i) * (100.0 + p->pPars->nRelaxRatio) / 100.0) );
        else  
            Tim_ManInitPoRequiredAll( (Tim_Man_t*)p->pGia->pManTime, Delay );
        Gia_ManForEachObjReverse1( p->pGia, pObj, i )
        {
            if ( Gia_ObjIsBuf(pObj) )
                Lf_ObjSetRequired( p, Gia_ObjFaninId0(pObj, i), Lf_ObjRequired(p, i) );
            else if ( Gia_ObjIsAnd(pObj) )
            {
                if ( Lf_ObjMapRefNum(p, i) )
                    Lf_ManCountMapRefsOne( p, i );
            }
            else if ( Gia_ObjIsCi(pObj) )
                Tim_ManSetCiRequired( (Tim_Man_t*)p->pGia->pManTime, Gia_ObjCioId(pObj), Lf_ObjRequired(p, i) );
            else if ( Gia_ObjIsCo(pObj) )
            {
                int reqTime = Tim_ManGetCoRequired( (Tim_Man_t*)p->pGia->pManTime, Gia_ObjCioId(pObj) );
                Lf_ObjSetRequired( p, Gia_ObjFaninId0(pObj, i), reqTime );
            }
            else assert( 0 );
        }
    }
    else
    {
        Gia_ManForEachCoDriverId( p->pGia, Id, i )
            Lf_ObjSetRequired( p, Id, p->pPars->fDoAverage ? (int)(Lf_ObjCoArrival(p, i) * (100.0 + p->pPars->nRelaxRatio) / 100.0) : Delay );
        Gia_ManForEachAndReverse( p->pGia, pObj, i )
            if ( Gia_ObjIsBuf(pObj) )
                Lf_ObjSetRequired( p, Gia_ObjFaninId0(pObj, i), Lf_ObjRequired(p, i) );
            else if ( Lf_ObjMapRefNum(p, i) )
                Lf_ManCountMapRefsOne( p, i );
    }
    if ( p->pPars->fUseMux7 )
        Gia_ManCleanMark0(p->pGia);
}    

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManCountMapRefsOne()

void Lf_ManCountMapRefsOne	(	Lf_Man_t *	p,
		int	iObj )

Definition at line 1617 of file giaLf.c.

{
    Lf_Bst_t * pBest = Lf_ObjReadBest( p, iObj );
    Lf_Cut_t * pCut = Lf_ObjCutBest( p, iObj );
    int k ,Required = Lf_ObjRequired( p, iObj );
    assert( Lf_ObjMapRefNum(p, iObj) > 0 );
    assert( Lf_BestIsMapped(pBest) );
    assert( !pCut->fMux7 );
//    assert( pCut->Delay <= Required );
    for ( k = 0; k < (int)pCut->nLeaves; k++ )
            Lf_ObjSetRequired( p, pCut->pLeaves[k], Required - 1 );
    if ( Vec_FltSize(&p->vSwitches) )
        p->Switches += Lf_CutSwitches(p, pCut);
    p->pPars->Edge += pCut->nLeaves;
    p->pPars->Area++;
}

Here is the caller graph for this function:

◆ Lf_ManDeriveMapping()

Gia_Man_t * Lf_ManDeriveMapping ( Lf_Man_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1709 of file giaLf.c.

{
    Vec_Int_t * vMapping;
    Lf_Cut_t * pCut;
    int i, k;
    assert( !p->pPars->fCutMin && p->pGia->vMapping == NULL );
    vMapping = Vec_IntAlloc( Gia_ManObjNum(p->pGia) + (int)p->pPars->Edge + (int)p->pPars->Area * 2 );
    Vec_IntFill( vMapping, Gia_ManObjNum(p->pGia), 0 );
    Gia_ManForEachAndId( p->pGia, i )
    {
        if ( !Lf_ObjMapRefNum(p, i) )
            continue;
        assert( !Gia_ObjIsBuf(Gia_ManObj(p->pGia,i)) );
        pCut = Lf_ObjCutBest( p, i );
        assert( !pCut->fMux7 );
        Vec_IntWriteEntry( vMapping, i, Vec_IntSize(vMapping) );
        Vec_IntPush( vMapping, pCut->nLeaves );
        for ( k = 0; k < (int)pCut->nLeaves; k++ )
            Vec_IntPush( vMapping, pCut->pLeaves[k] );
        Vec_IntPush( vMapping, i );
    }
    assert( Vec_IntCap(vMapping) == 16 || Vec_IntSize(vMapping) == Vec_IntCap(vMapping) );
    p->pGia->vMapping = vMapping;
    return p->pGia;
}

Here is the caller graph for this function:

◆ Lf_ManDeriveMappingCoarse()

Gia_Man_t * Lf_ManDeriveMappingCoarse ( Lf_Man_t * p )

Definition at line 1734 of file giaLf.c.

{
    Gia_Man_t * pNew, * pGia = p->pGia;
    Gia_Obj_t * pObj;
    Lf_Cut_t * pCut;
    int i, k;
    assert( !p->pPars->fCutMin && pGia->pMuxes );
    // create new manager
    pNew = Gia_ManStart( Gia_ManObjNum(pGia) );
    pNew->pName = Abc_UtilStrsav( pGia->pName );
    pNew->pSpec = Abc_UtilStrsav( pGia->pSpec );
    // start mapping
    pNew->vMapping = Vec_IntAlloc( Gia_ManObjNum(pGia) + 2*Gia_ManXorNum(pGia) + 2*Gia_ManMuxNum(pGia) + (int)p->pPars->Edge + 2*(int)p->pPars->Area + 4*(int)p->pPars->Mux7 );
    Vec_IntFill( pNew->vMapping, Gia_ManObjNum(pGia) + 2*Gia_ManXorNum(pGia) + 2*Gia_ManMuxNum(pGia), 0 );
    // process objects
    Gia_ManConst0(pGia)->Value = 0;
    Gia_ManForEachObj1( pGia, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            { pObj->Value = Gia_ManAppendCi( pNew ); continue; }
        if ( Gia_ObjIsCo(pObj) )
            { pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); continue; }
        if ( Gia_ObjIsBuf(pObj) )
            { pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) ); continue; }
        if ( Gia_ObjIsMuxId(pGia, i) )
            pObj->Value = Gia_ManAppendMux( pNew, Gia_ObjFanin2Copy(pGia, pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsXor(pObj) )
            pObj->Value = Gia_ManAppendXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else 
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        if ( !Lf_ObjMapRefNum(p, i) )
            continue;
        pCut = Lf_ObjCutBest( p, i );
        Vec_IntWriteEntry( pNew->vMapping, Abc_Lit2Var(pObj->Value), Vec_IntSize(pNew->vMapping) );
        Vec_IntPush( pNew->vMapping, pCut->nLeaves );
        for ( k = 0; k < (int)pCut->nLeaves; k++ )
            Vec_IntPush( pNew->vMapping, Abc_Lit2Var(Gia_ManObj(pGia, pCut->pLeaves[k])->Value) );
        Vec_IntPush( pNew->vMapping, pCut->fMux7 ? -Abc_Lit2Var(pObj->Value) : Abc_Lit2Var(pObj->Value) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(pGia) );
    assert( Vec_IntCap(pNew->vMapping) == 16 || Vec_IntSize(pNew->vMapping) == Vec_IntCap(pNew->vMapping) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManDeriveMappingGia()

Gia_Man_t * Lf_ManDeriveMappingGia ( Lf_Man_t * p )

Definition at line 1849 of file giaLf.c.

{
    Gia_Man_t * pNew; 
    Gia_Obj_t * pObj; 
    Vec_Int_t * vCopies   = Vec_IntStartFull( Gia_ManObjNum(p->pGia) );
    Vec_Int_t * vMapping  = Vec_IntStart( 2*Gia_ManObjNum(p->pGia) + (int)p->pPars->Edge + 2*(int)p->pPars->Area + 4*(int)p->pPars->Mux7 );
    Vec_Int_t * vMapping2 = Vec_IntStart( (int)p->pPars->Edge + 2*(int)p->pPars->Area + 1000 );
    Vec_Int_t * vCover    = Vec_IntAlloc( 1 << 16 );
    Vec_Int_t * vLeaves   = Vec_IntAlloc( 16 );
    Lf_Cut_t * pCut;
    int i, iLit; 
    assert( p->pPars->fCutMin );
    // create new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p->pGia) );
    pNew->pName = Abc_UtilStrsav( p->pGia->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pGia->pSpec );
    Vec_IntWriteEntry( vCopies, 0, 0 );
    Gia_ManForEachObj1( p->pGia, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
        {
            Vec_IntWriteEntry( vCopies, i, Gia_ManAppendCi(pNew) );
            continue;
        }
        if ( Gia_ObjIsCo(pObj) )
        {
            iLit = Vec_IntEntry( vCopies, Gia_ObjFaninId0p(p->pGia, pObj) );
            iLit = Gia_ManAppendCo( pNew, Abc_LitNotCond(iLit, Gia_ObjFaninC0(pObj)) );
            continue;
        }
        if ( Gia_ObjIsBuf(pObj) )
        {
            iLit = Vec_IntEntry( vCopies, Gia_ObjFaninId0p(p->pGia, pObj) );
            iLit = Gia_ManAppendBuf( pNew, Abc_LitNotCond(iLit, Gia_ObjFaninC0(pObj)) );
            Vec_IntWriteEntry( vCopies, i, iLit );
            continue;
        }
        if ( !Lf_ObjMapRefNum(p, i) )
            continue;
        pCut = Lf_ObjCutBest( p, i );
        assert( pCut->iFunc >= 0 );
        if ( pCut->nLeaves == 0 )
        {
            assert( Abc_Lit2Var(pCut->iFunc) == 0 );
            Vec_IntWriteEntry( vCopies, i, pCut->iFunc );
            continue;
        }
        if ( pCut->nLeaves == 1 )
        {
            assert( Abc_Lit2Var(pCut->iFunc) == 1 );
            iLit = Vec_IntEntry( vCopies, pCut->pLeaves[0] );
            Vec_IntWriteEntry( vCopies, i, Abc_LitNotCond(iLit, Abc_LitIsCompl(pCut->iFunc)) );
            continue;
        }
        iLit = Lf_ManDerivePart( p, pNew, vMapping, vMapping2, vCopies, pCut, vLeaves, vCover, pObj );
        Vec_IntWriteEntry( vCopies, i, Abc_LitNotCond(iLit, Abc_LitIsCompl(pCut->iFunc)) );
    }
    Vec_IntFree( vCopies );
    Vec_IntFree( vCover );
    Vec_IntFree( vLeaves );
    // finish mapping 
    if ( Vec_IntSize(vMapping) > Gia_ManObjNum(pNew) )
        Vec_IntShrink( vMapping, Gia_ManObjNum(pNew) );
    else
        Vec_IntFillExtra( vMapping, Gia_ManObjNum(pNew), 0 );
    assert( Vec_IntSize(vMapping) == Gia_ManObjNum(pNew) );
    Vec_IntForEachEntry( vMapping, iLit, i )
        if ( iLit > 0 )
            Vec_IntAddToEntry( vMapping, i, Gia_ManObjNum(pNew) );
    Vec_IntAppend( vMapping, vMapping2 );
    Vec_IntFree( vMapping2 );
    // attach mapping and packing
    assert( pNew->vMapping == NULL );
    pNew->vMapping = vMapping;
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p->pGia) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManFree()

void Lf_ManFree ( Lf_Man_t * p )

Definition at line 1981 of file giaLf.c.

{
    ABC_FREE( p->pPars->pTimesArr );
    ABC_FREE( p->pPars->pTimesReq );
    if ( p->pPars->fCutMin )
        Vec_MemHashFree( p->vTtMem );
    if ( p->pPars->fCutMin )
        Vec_MemFree( p->vTtMem );
    Vec_PtrFreeData( &p->vMemSets );
    Vec_PtrFreeData( &p->vFreePages );
    Vec_PtrFreeData( &p->vStoreOld.vPages );
    Vec_PtrFreeData( &p->vStoreNew.vPages );
    ABC_FREE( p->vMemSets.pArray );
    ABC_FREE( p->vFreePages.pArray );
    ABC_FREE( p->vStoreOld.vPages.pArray );
    ABC_FREE( p->vStoreNew.vPages.pArray );
    ABC_FREE( p->vFreePages.pArray );
    ABC_FREE( p->vFreeSets.pArray );
    ABC_FREE( p->vOffsets.pArray );
    ABC_FREE( p->vRequired.pArray );
    ABC_FREE( p->vCutSets.pArray );
    ABC_FREE( p->vFlowRefs.pArray );
    ABC_FREE( p->vMapRefs.pArray );
    ABC_FREE( p->vSwitches.pArray );
    ABC_FREE( p->vCiArrivals.pArray );
    ABC_FREE( p->pObjBests );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Lf_ManPerformMapping()

Gia_Man_t * Lf_ManPerformMapping	(	Gia_Man_t *	p,
		Jf_Par_t *	pPars )

Definition at line 2242 of file giaLf.c.

{
    Gia_Man_t * pNew;
    if ( p->pManTime && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) && Gia_ManIsNormalized(p) )
    {
        Tim_Man_t * pTimOld = (Tim_Man_t *)p->pManTime;
        p->pManTime = Tim_ManDup( pTimOld, 1 );
        pNew = Gia_ManDupUnnormalize( p );
        if ( pNew == NULL )
            return NULL;
        Gia_ManTransferTiming( pNew, p );
        p = pNew;
        // mapping
        pNew = Lf_ManPerformMappingInt( p, pPars );
        if ( pNew != p )
        {
            Gia_ManTransferTiming( pNew, p );
            Gia_ManStop( p );
        }
        // normalize
        pNew = Gia_ManDupNormalize( p = pNew, 0 );
        Gia_ManTransferMapping( pNew, p );
//        Gia_ManTransferPacking( pNew, p );
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p ); // do not delete if the original one!
        // cleanup
        Tim_ManStop( (Tim_Man_t *)pNew->pManTime );
        pNew->pManTime = pTimOld;
        assert( Gia_ManIsNormalized(pNew) );
    }
    else 
    {
        // mapping
        pNew = Lf_ManPerformMappingInt( p, pPars );
        Gia_ManTransferTiming( pNew, p );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManPerformMappingInt()

Gia_Man_t * Lf_ManPerformMappingInt	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars )

Definition at line 2182 of file giaLf.c.

{
    int fUsePowerMode = 0;
    Lf_Man_t * p;
    Gia_Man_t * pNew, * pCls;
    if ( pPars->fUseMux7 )
        pPars->fCoarsen = 1, pPars->nRoundsEla = 0;
    if ( Gia_ManHasChoices(pGia) || pPars->nLutSizeMux )
        pPars->fCutMin = 1; 
    if ( pPars->fCoarsen )
    {
        pCls = Gia_ManDupMuxes(pGia, pPars->nCoarseLimit);
        pCls->pManTime = pGia->pManTime; pGia->pManTime = NULL;
    }
    else pCls = pGia;
    p = Lf_ManAlloc( pCls, pPars );
    if ( pPars->fVerbose && pPars->fCoarsen )
    {
        printf( "Initial " );  Gia_ManPrintMuxStats( pGia );  printf( "\n" );
        printf( "Derived " );  Gia_ManPrintMuxStats( pCls );  printf( "\n" );
    }
    Lf_ManPrintInit( p );
 
    // power mode
    if ( fUsePowerMode && Vec_FltSize(&p->vSwitches) )
        pPars->fPower = 0;
 
    // perform mapping
    for ( p->Iter = 0; p->Iter < p->pPars->nRounds; p->Iter++ )
        Lf_ManComputeMapping( p );
    p->fUseEla = 1;
    for ( ; p->Iter < p->pPars->nRounds + pPars->nRoundsEla; p->Iter++ )
        Lf_ManComputeMapping( p );
 
    // power mode
    if ( fUsePowerMode && Vec_FltSize(&p->vSwitches) )
    {
        pPars->fPower = 1;
        for ( ; p->Iter < p->pPars->nRounds + pPars->nRoundsEla + 2; p->Iter++ )
            Lf_ManComputeMapping( p );
    }
 
    if ( pPars->fVeryVerbose && pPars->fCutMin )
        Vec_MemDumpTruthTables( p->vTtMem, Gia_ManName(p->pGia), pPars->nLutSize );
    if ( pPars->fCutMin )
        pNew = Lf_ManDeriveMappingGia( p );
    else if ( pPars->fCoarsen )
        pNew = Lf_ManDeriveMappingCoarse( p );
    else
        pNew = Lf_ManDeriveMapping( p );
    Gia_ManMappingVerify( pNew );
    Lf_ManPrintQuit( p, pNew );
    Lf_ManFree( p );
    if ( pCls != pGia )
    {
        pGia->pManTime = pCls->pManTime; pCls->pManTime = NULL;
        Gia_ManStop( pCls );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManPrintInit()

void Lf_ManPrintInit ( Lf_Man_t * p )

Definition at line 2066 of file giaLf.c.

{
    if ( !p->pPars->fVerbose )
        return;
    printf( "LutSize = %d  ", p->pPars->nLutSize );
    printf( "CutNum = %d  ",  p->pPars->nCutNum );
    printf( "Iter = %d  ",    p->pPars->nRounds + p->pPars->nRoundsEla );
    if ( p->pPars->nRelaxRatio )
    printf( "Ratio = %d  ",   p->pPars->nRelaxRatio );
    printf( "Edge = %d  ",    p->pPars->fOptEdge );
    if ( p->pPars->DelayTarget != -1 )
    printf( "Delay = %d  ",   p->pPars->DelayTarget );
    printf( "CutMin = %d  ",  p->pPars->fCutMin );
    printf( "Coarse = %d  ",  p->pPars->fCoarsen );
    printf( "Cut/Set = %d/%d Bytes", 8*p->nCutWords, 8*p->nSetWords );
    printf( "\n" );
    printf( "Computing cuts...\r" );
    fflush( stdout );
}

Here is the caller graph for this function:

◆ Lf_ManPrintQuit()

void Lf_ManPrintQuit	(	Lf_Man_t *	p,
		Gia_Man_t *	pNew )

Definition at line 2085 of file giaLf.c.

{
    float MemGia   = Gia_ManMemory(p->pGia) / (1<<20);
    float MemMan   = 1.0 * sizeof(int) * (2 * Gia_ManObjNum(p->pGia) + 3 * Gia_ManAndNotBufNum(p->pGia)) / (1<<20); // offset, required, cutsets, maprefs, flowrefs
    float MemCutsB = 1.0 * (p->vStoreOld.MaskPage + 1) * (Vec_PtrSize(&p->vFreePages) + Vec_PtrSize(&p->vStoreOld.vPages)) / (1<<20) + 1.0 * sizeof(Lf_Bst_t) * Gia_ManAndNotBufNum(p->pGia) / (1<<20);
    float MemCutsF = 1.0 * sizeof(word) * p->nSetWords * (1<<LF_LOG_PAGE) * Vec_PtrSize(&p->vMemSets) / (1<<20);
    float MemTt    = p->vTtMem ? Vec_MemMemory(p->vTtMem) / (1<<20) : 0;
    float MemMap   = Vec_IntMemory(pNew->vMapping) / (1<<20);
    if ( p->CutCount[0] == 0 )
        p->CutCount[0] = 1;
    if ( !p->pPars->fVerbose )
    {
        int i, CountOver[2] = {0};
        int nLutSize = p->pPars->fCutGroup ? p->pPars->nLutSize/2 : p->pPars->nLutSize;
        Gia_ManForEachLut( pNew, i )
            CountOver[Gia_ObjLutSize(pNew, i) > nLutSize]++;
        if ( p->pPars->fCutGroup )
            printf( "Created %d regular %d-LUTs and %d dual %d-LUTs. The total of %d %d-LUTs.\n", 
            CountOver[0], nLutSize, CountOver[1], nLutSize, CountOver[0] + 2*CountOver[1], nLutSize );
        return;
    }
    printf( "CutPair = %.0f  ",         p->CutCount[0] );
    printf( "Merge = %.0f (%.2f %%)  ", p->CutCount[1], 100.0*p->CutCount[1]/p->CutCount[0] );
    printf( "Eval = %.0f (%.2f %%)  ",  p->CutCount[2], 100.0*p->CutCount[2]/p->CutCount[0] );
    printf( "Cut = %.0f (%.2f %%)  ",   p->CutCount[3], 100.0*p->CutCount[3]/p->CutCount[0] );
    printf( "\n" );
    printf( "Gia = %.2f MB  ",          MemGia );
    printf( "Man = %.2f MB  ",          MemMan ); 
    printf( "Best = %.2f MB  ",         MemCutsB );
    printf( "Front = %.2f MB   ",       MemCutsF );
    printf( "Map = %.2f MB  ",          MemMap ); 
    printf( "TT = %.2f MB  ",           MemTt ); 
    printf( "Total = %.2f MB",          MemGia + MemMan + MemCutsB + MemCutsF + MemMap + MemTt ); 
    printf( "\n" );
    if ( 1 )
    {
        int i;
        for ( i = 0; i <= p->pPars->nLutSize; i++ )
            printf( "%d:%d  ", i, p->nCutCounts[i] );
        printf( "Equal = %d (%.0f %%) ", p->nCutEqual, 100.0 * p->nCutEqual / p->Iter / Gia_ManAndNotBufNum(p->pGia) );
        if ( p->vTtMem )
            printf( "TT = %d (%.2f %%)  ", Vec_MemEntryNum(p->vTtMem), 100.0 * Vec_MemEntryNum(p->vTtMem) / p->CutCount[2] );
        if ( p->pGia->pMuxes && p->nCutMux )
            printf( "MuxTT = %d (%.0f %%) ", p->nCutMux, 100.0 * p->nCutMux / p->Iter / Gia_ManMuxNum(p->pGia) );
        printf( "\n" );
    }
    printf( "CoDrvs = %d (%.2f %%)  ",  p->nCoDrivers, 100.0*p->nCoDrivers/Gia_ManCoNum(p->pGia) );
    printf( "CoInvs = %d (%.2f %%)  ",  p->nInverters, 100.0*p->nInverters/Gia_ManCoNum(p->pGia) );
    printf( "Front = %d (%.2f %%)  ",   p->nFrontMax,  100.0*p->nFrontMax/Gia_ManAndNum(p->pGia) );
    printf( "TimeFails = %d   ",        p->nTimeFails );
    Abc_PrintTime( 1, "Time",    Abc_Clock() - p->clkStart );
    fflush( stdout );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManPrintStats()

void Lf_ManPrintStats	(	Lf_Man_t *	p,
		char *	pTitle )

Definition at line 2050 of file giaLf.c.

{
    if ( !p->pPars->fVerbose )
        return;
    printf( "%s :  ", pTitle );
    printf( "Level =%6lu   ",   (long)p->pPars->Delay );
    printf( "Area =%9lu   ",    (long)p->pPars->Area );
    printf( "Edge =%9lu   ",    (long)p->pPars->Edge );
    printf( "LUT =%9lu  ",      (long)p->pPars->Area+p->nInverters );
    if ( Vec_FltSize(&p->vSwitches) )
        printf( "Swt =%8.1f  ", p->Switches );
    if ( p->pPars->fUseMux7 )
        printf( "Mux7 =%7lu  ", (long)p->pPars->Mux7 );
    Abc_PrintTime( 1, "Time", Abc_Clock() - p->clkStart );
    fflush( stdout );
}

Here is the caller graph for this function:

◆ Lf_ManSetCutRefs()

void Lf_ManSetCutRefs ( Lf_Man_t * p )

Definition at line 1448 of file giaLf.c.

{
    Gia_Obj_t * pObj; int i;
    if ( Vec_PtrSize(&p->vMemSets) * (1 << LF_LOG_PAGE) != Vec_IntSize(&p->vFreeSets) )
        printf( "The number of used cutsets = %d.\n", Vec_PtrSize(&p->vMemSets) * (1 << LF_LOG_PAGE) - Vec_IntSize(&p->vFreeSets) );
    Gia_ManForEachAnd( p->pGia, pObj, i )
    {
        assert( pObj->Value == 0 );
        if ( Gia_ObjIsBuf(pObj) )
            continue;
        if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin0(pObj)) )
            Gia_ObjFanin0(pObj)->Value++;
        if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin1(pObj)) )
            Gia_ObjFanin1(pObj)->Value++;
        if ( Gia_ObjIsMuxId(p->pGia, i) && Gia_ObjIsAndNotBuf(Gia_ObjFanin2(p->pGia, pObj)) )
            Gia_ObjFanin2(p->pGia, pObj)->Value++;
        if ( Gia_ObjSibl(p->pGia, i) && Gia_ObjIsAndNotBuf(Gia_ObjSiblObj(p->pGia, i)) )
            Gia_ObjSiblObj(p->pGia, i)->Value++;
    }
}

Here is the caller graph for this function:

◆ Lf_ManSetDefaultPars()

void Lf_ManSetDefaultPars ( Jf_Par_t * pPars )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2021 of file giaLf.c.

{
    memset( pPars, 0, sizeof(Jf_Par_t) );
    pPars->nLutSize     =  6;
    pPars->nCutNum      =  8;
    pPars->nProcNum     =  0;
    pPars->nRounds      =  4;
    pPars->nRoundsEla   =  1;
    pPars->nRelaxRatio  =  0;
    pPars->nCoarseLimit =  3;
    pPars->nAreaTuner   =  1;
    pPars->nVerbLimit   =  5;
    pPars->DelayTarget  = -1;
    pPars->fAreaOnly    =  0;
    pPars->fOptEdge     =  1; 
    pPars->fUseMux7     =  0;
    pPars->fPower       =  0;
    pPars->fCoarsen     =  1;
    pPars->fCutMin      =  0;
    pPars->fFuncDsd     =  0;
    pPars->fGenCnf      =  0;
    pPars->fPureAig     =  0;
    pPars->fCutHashing  =  0;
    pPars->fCutSimple   =  0;
    pPars->fVerbose     =  0;
    pPars->fVeryVerbose =  0;
    pPars->nLutSizeMax  =  LF_LEAF_MAX;
    pPars->nCutNumMax   =  LF_CUT_MAX;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManSetFlowRefs()

void Lf_ManSetFlowRefs	(	Gia_Man_t *	p,
		Vec_Flt_t *	vRefs,
		Vec_Int_t *	vOffsets )

Definition at line 1412 of file giaLf.c.

{
    int fDiscount = 1;
    Gia_Obj_t * pObj, * pCtrl, * pData0, * pData1; 
    int i, Id;
    Vec_FltFill( vRefs, Gia_ManAndNotBufNum(p), 0 );
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin0(pObj)) )
            Vec_FltAddToEntry( vRefs, Vec_IntEntry(vOffsets, Gia_ObjFaninId0(pObj, i)), 1 );
        if ( Gia_ObjIsBuf(pObj) )
            continue;
        if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin1(pObj)) )
            Vec_FltAddToEntry( vRefs, Vec_IntEntry(vOffsets, Gia_ObjFaninId1(pObj, i)), 1 );
        if ( p->pMuxes )
        {
            if ( Gia_ObjIsMuxId(p, i) && Gia_ObjIsAndNotBuf(Gia_ObjFanin2(p, pObj)) )
                Vec_FltAddToEntry( vRefs, Vec_IntEntry(vOffsets, Gia_ObjFaninId2(p, i)), 1 );
        }
        else if ( fDiscount && Gia_ObjIsMuxType(pObj) ) // discount XOR/MUX
        {
            pCtrl  = Gia_Regular(Gia_ObjRecognizeMux(pObj, &pData1, &pData0));
            pData0 = Gia_Regular(pData0);
            pData1 = Gia_Regular(pData1);
            if ( Gia_ObjIsAndNotBuf(pCtrl) )
                Vec_FltAddToEntry( vRefs, Vec_IntEntry(vOffsets, Gia_ObjId(p, pCtrl)), -1 );
            if ( pData0 == pData1 && Gia_ObjIsAndNotBuf(pData0) )
                Vec_FltAddToEntry( vRefs, Vec_IntEntry(vOffsets, Gia_ObjId(p, pData0)), -1 );
        }
    }
    Gia_ManForEachCoDriverId( p, Id, i )
        if ( Gia_ObjIsAndNotBuf(Gia_ManObj(p, Id)) )
            Vec_FltAddToEntry( vRefs, Vec_IntEntry(vOffsets, Id), 1 );
    for ( i = 0; i < Vec_FltSize(vRefs); i++ )
        Vec_FltUpdateEntry( vRefs, i, 1 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManSetMapRefs()

int Lf_ManSetMapRefs ( Lf_Man_t * p )

Definition at line 1520 of file giaLf.c.

{
    float Coef = 1.0 / (1.0 + (p->Iter + 1) * (p->Iter + 1));
    float * pFlowRefs; 
    int * pMapRefs, i;
    Gia_Obj_t * pObj;
    // compute delay
    int Delay = 0;
    for ( i = 0; i < Gia_ManCoNum(p->pGia); i++ )
        Delay = Abc_MaxInt( Delay, Lf_ObjCoArrival(p, i) );
    // check delay target
    if ( p->pPars->DelayTarget == -1 && p->pPars->nRelaxRatio )
        p->pPars->DelayTarget = (int)((float)Delay * (100.0 + p->pPars->nRelaxRatio) / 100.0);
    if ( p->pPars->DelayTarget != -1 )
    {
        if ( Delay < p->pPars->DelayTarget + 0.01 )
            Delay = p->pPars->DelayTarget;
        else if ( p->pPars->nRelaxRatio == 0 )
            Abc_Print( 0, "Relaxing user-specified delay target from %d to %d.\n", p->pPars->DelayTarget, Delay );
    } 
    p->pPars->Delay = Delay;
    // compute area/edges/required
    p->pPars->Mux7 = p->pPars->Area = p->pPars->Edge = p->Switches = 0;
    Vec_IntFill( &p->vMapRefs, Gia_ManAndNotBufNum(p->pGia), 0 );
    Vec_IntFill( &p->vRequired, Gia_ManObjNum(p->pGia), ABC_INFINITY );
    if ( p->pPars->fUseMux7 )
    {
        Gia_ManCleanMark0(p->pGia);
        Gia_ManForEachCi( p->pGia, pObj, i )
            pObj->fMark0 = 1;
    }
    if ( p->pGia->pManTime != NULL )
    {
        assert( !Gia_ManBufNum(p->pGia) );
        Tim_ManIncrementTravId( (Tim_Man_t*)p->pGia->pManTime );
        if ( p->pPars->fDoAverage )
            for ( i = 0; i < Gia_ManCoNum(p->pGia); i++ )
               Tim_ManSetCoRequired( (Tim_Man_t*)p->pGia->pManTime, i, (int)(Lf_ObjCoArrival(p, i) * (100.0 + p->pPars->nRelaxRatio) / 100.0) );
        else  
            Tim_ManInitPoRequiredAll( (Tim_Man_t*)p->pGia->pManTime, Delay );
        Gia_ManForEachObjReverse1( p->pGia, pObj, i )
        {
            if ( Gia_ObjIsBuf(pObj) )
                Lf_ObjSetRequired( p, Gia_ObjFaninId0(pObj, i), Lf_ObjRequired(p, i) );
            else if ( Gia_ObjIsAnd(pObj) )
            {
                if ( Lf_ObjMapRefNum(p, i) )
                    Lf_ManSetMapRefsOne( p, i );
            }
            else if ( Gia_ObjIsCi(pObj) )
                Tim_ManSetCiRequired( (Tim_Man_t*)p->pGia->pManTime, Gia_ObjCioId(pObj), Lf_ObjRequired(p, i) );
            else if ( Gia_ObjIsCo(pObj) )
            {
                int iDriverId = Gia_ObjFaninId0(pObj, i);
                int reqTime = Tim_ManGetCoRequired( (Tim_Man_t*)p->pGia->pManTime, Gia_ObjCioId(pObj) );
                Lf_ObjSetRequired( p, iDriverId, reqTime );
                if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin0(pObj)) )
                    Lf_ObjMapRefInc( p, iDriverId );
            }
            else assert( 0 );
        }
    }
    else
    {
        Gia_ManForEachCo( p->pGia, pObj, i )
        {
            int iDriverId = Gia_ObjFaninId0p(p->pGia, pObj);
            int reqTime = p->pPars->fDoAverage ? (int)(Lf_ObjCoArrival(p, i) * (100.0 + p->pPars->nRelaxRatio) / 100.0) : Delay;
            Lf_ObjSetRequired( p, iDriverId, reqTime );
            if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin0(pObj)) )
                Lf_ObjMapRefInc( p, iDriverId );
        }
        Gia_ManForEachAndReverse( p->pGia, pObj, i )
        {
            if ( Gia_ObjIsBuf(pObj) )
            {
                Lf_ObjSetRequired( p, Gia_ObjFaninId0(pObj, i), Lf_ObjRequired(p, i) );
                if ( Gia_ObjIsAndNotBuf(Gia_ObjFanin0(pObj)) )
                    Lf_ObjMapRefInc( p, Gia_ObjFaninId0(pObj, i) );
            }
            else if ( Lf_ObjMapRefNum(p, i) )
                Lf_ManSetMapRefsOne( p, i );
        }
    }
    if ( p->pPars->fUseMux7 )
        Gia_ManCleanMark0(p->pGia);
    // blend references
    assert( Vec_IntSize(&p->vMapRefs)  == Gia_ManAndNotBufNum(p->pGia) );
    assert( Vec_FltSize(&p->vFlowRefs) == Gia_ManAndNotBufNum(p->pGia) );
    pMapRefs  = Vec_IntArray(&p->vMapRefs);
    pFlowRefs = Vec_FltArray(&p->vFlowRefs);
    for ( i = 0; i < Vec_IntSize(&p->vMapRefs); i++ )
        pFlowRefs[i] = Coef * pFlowRefs[i] + (1.0 - Coef) * Abc_MaxFloat(1, pMapRefs[i]);
//        pFlowRefs[i] = 0.2 * pFlowRefs[i] + 0.8 * Abc_MaxFloat(1, pMapRefs[i]);
    return p->pPars->Area;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManSetMapRefsOne()

void Lf_ManSetMapRefsOne	(	Lf_Man_t *	p,
		int	iObj )

Definition at line 1485 of file giaLf.c.

{
    Lf_Cut_t * pCut;
    Lf_Bst_t * pBest = Lf_ObjReadBest( p, iObj );
    int k, Index, Required = Lf_ObjRequired( p, iObj );
    assert( Lf_ObjMapRefNum(p, iObj) > 0 );
    assert( !pBest->Cut[0].fUsed && !pBest->Cut[1].fUsed );
    if ( !p->pPars->fUseMux7 || !Lf_ManSetMuxCut(p, pBest, iObj, Required) )
    {
        Index = (int)(Lf_BestDiffCuts(pBest) && pBest->Delay[1] <= Required);
        pBest->Cut[Index].fUsed = 1;
    }
    pCut = Lf_ObjCutBest( p, iObj );
    assert( !pCut->fMux7 || pCut->nLeaves == 3 );
//    assert( pCut->Delay <= Required );
    for ( k = 0; k < (int)pCut->nLeaves; k++ )
    {
//        if ( pCut->fMux7 && pCut->pLeaves[k] != Gia_ObjFaninId2(p->pGia, iObj) )
//            Lf_ObjSetRequired( p, pCut->pLeaves[k], Required );
//        else
            Lf_ObjSetRequired( p, pCut->pLeaves[k], Required - 1 );
        if ( Gia_ObjIsAndNotBuf(Gia_ManObj(p->pGia, pCut->pLeaves[k])) )
            Lf_ObjMapRefInc( p, pCut->pLeaves[k] );
    }
    if ( pCut->fMux7 )
    {
        p->pPars->Mux7++;
        p->pPars->Edge++;
        return;
    }
    if ( Vec_FltSize(&p->vSwitches) )
        p->Switches += Lf_CutSwitches(p, pCut);
    p->pPars->Edge += pCut->nLeaves;
    p->pPars->Area++;
}

Here is the caller graph for this function:

◆ Lf_ManTtIsMux()

int Lf_ManTtIsMux ( word t )

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

Synopsis [Detect MUX truth tables.]

Description []

SideEffects []

SeeAlso []

Definition at line 271 of file giaLf.c.

{
    static unsigned s_Muxes[24] = {
        (~0xAAAAAAAA & ~0xCCCCCCCC) | ( 0xAAAAAAAA & ~0xF0F0F0F0),
        (~0xAAAAAAAA & ~0xCCCCCCCC) | ( 0xAAAAAAAA &  0xF0F0F0F0),
        (~0xAAAAAAAA &  0xCCCCCCCC) | ( 0xAAAAAAAA & ~0xF0F0F0F0),
        (~0xAAAAAAAA &  0xCCCCCCCC) | ( 0xAAAAAAAA &  0xF0F0F0F0),
        ( 0xAAAAAAAA & ~0xCCCCCCCC) | (~0xAAAAAAAA & ~0xF0F0F0F0),
        ( 0xAAAAAAAA & ~0xCCCCCCCC) | (~0xAAAAAAAA &  0xF0F0F0F0),
        ( 0xAAAAAAAA &  0xCCCCCCCC) | (~0xAAAAAAAA & ~0xF0F0F0F0),
        ( 0xAAAAAAAA &  0xCCCCCCCC) | (~0xAAAAAAAA &  0xF0F0F0F0),
 
        (~0xCCCCCCCC & ~0xAAAAAAAA) | ( 0xCCCCCCCC & ~0xF0F0F0F0),
        (~0xCCCCCCCC & ~0xAAAAAAAA) | ( 0xCCCCCCCC &  0xF0F0F0F0),
        (~0xCCCCCCCC &  0xAAAAAAAA) | ( 0xCCCCCCCC & ~0xF0F0F0F0),
        (~0xCCCCCCCC &  0xAAAAAAAA) | ( 0xCCCCCCCC &  0xF0F0F0F0),
        ( 0xCCCCCCCC & ~0xAAAAAAAA) | (~0xCCCCCCCC & ~0xF0F0F0F0),
        ( 0xCCCCCCCC & ~0xAAAAAAAA) | (~0xCCCCCCCC &  0xF0F0F0F0),
        ( 0xCCCCCCCC &  0xAAAAAAAA) | (~0xCCCCCCCC & ~0xF0F0F0F0),
        ( 0xCCCCCCCC &  0xAAAAAAAA) | (~0xCCCCCCCC &  0xF0F0F0F0),
 
        (~0xF0F0F0F0 & ~0xCCCCCCCC) | ( 0xF0F0F0F0 & ~0xAAAAAAAA),
        (~0xF0F0F0F0 & ~0xCCCCCCCC) | ( 0xF0F0F0F0 &  0xAAAAAAAA),
        (~0xF0F0F0F0 &  0xCCCCCCCC) | ( 0xF0F0F0F0 & ~0xAAAAAAAA),
        (~0xF0F0F0F0 &  0xCCCCCCCC) | ( 0xF0F0F0F0 &  0xAAAAAAAA),
        ( 0xF0F0F0F0 & ~0xCCCCCCCC) | (~0xF0F0F0F0 & ~0xAAAAAAAA),
        ( 0xF0F0F0F0 & ~0xCCCCCCCC) | (~0xF0F0F0F0 &  0xAAAAAAAA),
        ( 0xF0F0F0F0 &  0xCCCCCCCC) | (~0xF0F0F0F0 & ~0xAAAAAAAA),
        ( 0xF0F0F0F0 &  0xCCCCCCCC) | (~0xF0F0F0F0 &  0xAAAAAAAA)
    };
    int i;
    for ( i = 0; i < 24; i++ )
        if ( ((unsigned)t) == s_Muxes[i] )
            return 1;
    return 0;
}

◆ Lf_ObjArrival_rec()

int Lf_ObjArrival_rec	(	Lf_Man_t *	p,
		Gia_Obj_t *	pDriver )

Definition at line 162 of file giaLf.c.

{
    if ( Gia_ObjIsBuf(pDriver) )
        return Lf_ObjArrival_rec( p, Gia_ObjFanin0(pDriver) );
    if ( Gia_ObjIsAnd(pDriver) )
        return Lf_ObjReadBest(p, Gia_ObjId(p->pGia, pDriver))->Delay[0];
    if ( Gia_ObjIsCi(pDriver) )
        return Lf_ObjCiArrival(p, Gia_ObjCioId(pDriver));
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ObjCoArrival2_rec()

int Lf_ObjCoArrival2_rec	(	Lf_Man_t *	p,
		Gia_Obj_t *	pDriver )

Definition at line 183 of file giaLf.c.

{
    if ( Gia_ObjIsBuf(pDriver) )
        return Lf_ObjCoArrival2_rec( p, Gia_ObjFanin0(pDriver) );
    if ( Gia_ObjIsAnd(pDriver) )
    {
        Lf_Bst_t * pBest = Lf_ObjReadBest(p, Gia_ObjId(p->pGia, pDriver));
        int Index = Lf_BestCutIndex( pBest );
        assert( Index < 2 || Gia_ObjIsMux(p->pGia, pDriver) );
        return pBest->Delay[Index];
    }
    if ( Gia_ObjIsCi(pDriver) )
        return Lf_ObjCiArrival(p, Gia_ObjCioId(pDriver));
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ObjMergeOrder()

void Lf_ObjMergeOrder	(	Lf_Man_t *	p,
		int	iObj )

Definition at line 1186 of file giaLf.c.

{
    word CutSet[LF_CUT_MAX][LF_CUT_WORDS] = {{0}};
    Lf_Cut_t * pCutSet0, * pCutSet1, * pCutSet2, * pCut0, * pCut1, * pCut2;
    Lf_Cut_t * pCutSet = (Lf_Cut_t *)CutSet, * pCutsR[LF_CUT_MAX];
    Gia_Obj_t * pObj = Gia_ManObj(p->pGia, iObj);
    Lf_Bst_t * pBest = Lf_ObjReadBest(p, iObj);
    float FlowRefs = Lf_ObjFlowRefs(p, iObj);
    int Required   = Lf_ObjRequired(p, iObj);
    int nLutSize   = p->pPars->fCutGroup ? p->pPars->nLutSize/2 : p->pPars->nLutSize;
    int nCutNum    = p->pPars->nCutNum;
    int nCutWords  = p->nCutWords;
    int fComp0     = Gia_ObjFaninC0(pObj);
    int fComp1     = Gia_ObjFaninC1(pObj);
    int nCuts0     = Lf_ManPrepareSet( p, Gia_ObjFaninId0(pObj, iObj), 0, &pCutSet0 );
    int nCuts1     = Lf_ManPrepareSet( p, Gia_ObjFaninId1(pObj, iObj), 1, &pCutSet1 );
    int iSibl      = Gia_ObjSibl(p->pGia, iObj);
    int i, k, n, iCutUsed, nCutsR = 0;
    float Value1 = -1, Value2 = -1;
    assert( !Gia_ObjIsBuf(pObj) );
    Lf_CutSetForEachCut( nCutWords, pCutSet, pCut0, i, nCutNum )
        pCutsR[i] = pCut0;
    if ( p->Iter )
    {
        assert( nCutsR == 0 );
        // load cuts
        Lf_MemLoadCut( &p->vStoreOld, pBest->Cut[0].Handle, iObj, pCutsR[0], p->pPars->fCutMin, 1 );
        if ( Lf_BestDiffCuts(pBest) )
            Lf_MemLoadCut( &p->vStoreOld, pBest->Cut[1].Handle, iObj, pCutsR[1], p->pPars->fCutMin, 1 );
        // deref the cut
        if ( p->fUseEla && Lf_ObjMapRefNum(p, iObj) > 0 )
            Value1 = Lf_CutDeref_rec( p, pCutsR[Lf_BestIndex(pBest)] );
        // update required times
        if ( Required == ABC_INFINITY )//&& !p->fUseEla )
            Required = Lf_CutRequired( p, pCutsR[0] );
        // compute parameters
        Lf_CutParams( p, pCutsR[nCutsR++], Required, FlowRefs, pObj );
        if ( Lf_BestDiffCuts(pBest) )
        {
            assert( nCutsR == 1 );
            Lf_CutParams( p, pCutsR[nCutsR], Required, FlowRefs, pObj );
            nCutsR = Lf_SetAddCut( pCutsR, nCutsR, nCutNum );
        }
        if ( pCutsR[0]->fLate )
            p->nTimeFails++;
    }
    if ( iSibl )
    {
        Gia_Obj_t * pObjE = Gia_ObjSiblObj(p->pGia, iObj);
        int fCompE = Gia_ObjPhase(pObj) ^ Gia_ObjPhase(pObjE);
        int nCutsE = Lf_ManPrepareSet( p, iSibl, 2, &pCutSet2 );
        Lf_CutSetForEachCut( nCutWords, pCutSet2, pCut2, n, nCutsE )
        {
            if ( pCut2->pLeaves[0] == iSibl )
                continue;
            Lf_CutCopy( pCutsR[nCutsR], pCut2, nCutWords );
            if ( pCutsR[nCutsR]->iFunc >= 0 )
                pCutsR[nCutsR]->iFunc = Abc_LitNotCond( pCutsR[nCutsR]->iFunc, fCompE );
            Lf_CutParams( p, pCutsR[nCutsR], Required, FlowRefs, pObj );
            nCutsR = Lf_SetAddCut( pCutsR, nCutsR, nCutNum );
        }
    }
    if ( Gia_ObjIsMuxId(p->pGia, iObj) )
    {
        Lf_Cut_t * pCutSave = NULL;
        int fComp2 = Gia_ObjFaninC2(p->pGia, pObj);
        int nCuts2 = Lf_ManPrepareSet( p, Gia_ObjFaninId2(p->pGia, iObj), 2, &pCutSet2 );
        p->CutCount[0] += nCuts0 * nCuts1 * nCuts2;
        Lf_CutSetForEachCut( nCutWords, pCutSet0, pCut0, i, nCuts0 ) if ( (int)pCut0->nLeaves <= nLutSize )
        Lf_CutSetForEachCut( nCutWords, pCutSet1, pCut1, k, nCuts1 ) if ( (int)pCut1->nLeaves <= nLutSize )
        Lf_CutSetForEachCut( nCutWords, pCutSet2, pCut2, n, nCuts2 ) if ( (int)pCut2->nLeaves <= nLutSize )
        {
            pCutSave = pCut2;
            if ( Lf_CutCountBits(pCut0->Sign | pCut1->Sign | pCut2->Sign) > nLutSize )
                continue;
            p->CutCount[1]++; 
            if ( !Lf_CutMergeOrderMux(pCut0, pCut1, pCut2, pCutsR[nCutsR], nLutSize) )
                continue;
            if ( Lf_SetLastCutIsContained(pCutsR, nCutsR) )
                continue;
            p->CutCount[2]++;
            if ( p->pPars->fCutMin && Lf_CutComputeTruthMux(p, pCut0, pCut1, pCut2, fComp0, fComp1, fComp2, pCutsR[nCutsR]) )
                pCutsR[nCutsR]->Sign = Lf_CutGetSign(pCutsR[nCutsR]);
            if ( p->pPars->nLutSizeMux && p->pPars->nLutSizeMux == (int)pCutsR[nCutsR]->nLeaves && 
                Lf_ManFindCofVar(Lf_CutTruth(p,pCutsR[nCutsR]), Abc_Truth6WordNum(nLutSize), pCutsR[nCutsR]->nLeaves) == -1 )
                continue;
            Lf_CutParams( p, pCutsR[nCutsR], Required, FlowRefs, pObj );
            nCutsR = Lf_SetAddCut( pCutsR, nCutsR, nCutNum );
        }
        if ( p->pPars->fCutGroup )
        {
            assert( pCutSave->nLeaves == 1 );
            assert( pCutSave->pLeaves[0] == Gia_ObjFaninId2(p->pGia, iObj) );
            Lf_CutSetForEachCut( nCutWords, pCutSet0, pCut0, i, nCuts0 ) if ( (int)pCut0->nLeaves <= nLutSize )
            Lf_CutSetForEachCut( nCutWords, pCutSet1, pCut1, k, nCuts1 ) if ( (int)pCut1->nLeaves <= nLutSize )
            {
                assert( (int)pCut0->nLeaves + (int)pCut1->nLeaves + 1 <= p->pPars->nLutSize );
    //            if ( Lf_CutCountBits(pCut0->Sign | pCut1->Sign | pCutSave->Sign) > p->pPars->nLutSize )
    //                continue;
                p->CutCount[1]++; 
                if ( !Lf_CutMergeOrderMux(pCut0, pCut1, pCutSave, pCutsR[nCutsR], p->pPars->nLutSize) )
                    continue;
                if ( Lf_SetLastCutIsContained(pCutsR, nCutsR) )
                    continue;
                p->CutCount[2]++;
                if ( p->pPars->fCutMin && Lf_CutComputeTruthMux(p, pCut0, pCut1, pCutSave, fComp0, fComp1, fComp2, pCutsR[nCutsR]) )
                    pCutsR[nCutsR]->Sign = Lf_CutGetSign(pCutsR[nCutsR]);
    //            if ( p->pPars->nLutSizeMux && p->pPars->nLutSizeMux == (int)pCutsR[nCutsR]->nLeaves && 
    //                Lf_ManFindCofVar(Lf_CutTruth(p,pCutsR[nCutsR]), Abc_Truth6WordNum(nLutSize), pCutsR[nCutsR]->nLeaves) == -1 )
    //                continue;
                Lf_CutParams( p, pCutsR[nCutsR], Required, FlowRefs, pObj );
                nCutsR = Lf_SetAddCut( pCutsR, nCutsR, nCutNum );
            }
        }
    }
    else
    {
        int fIsXor = Gia_ObjIsXor(pObj);
        p->CutCount[0] += nCuts0 * nCuts1;
        Lf_CutSetForEachCut( nCutWords, pCutSet0, pCut0, i, nCuts0 ) if ( (int)pCut0->nLeaves <= nLutSize )
        Lf_CutSetForEachCut( nCutWords, pCutSet1, pCut1, k, nCuts1 ) if ( (int)pCut1->nLeaves <= nLutSize )
        {
            if ( (int)(pCut0->nLeaves + pCut1->nLeaves) > nLutSize && Lf_CutCountBits(pCut0->Sign | pCut1->Sign) > nLutSize )
                continue;
            p->CutCount[1]++; 
            if ( !Lf_CutMergeOrder(pCut0, pCut1, pCutsR[nCutsR], nLutSize) )
                continue;
            if ( Lf_SetLastCutIsContained(pCutsR, nCutsR) )
                continue;
            p->CutCount[2]++;
            if ( p->pPars->fCutMin && Lf_CutComputeTruth(p, pCut0, pCut1, fComp0, fComp1, pCutsR[nCutsR], fIsXor) )
                pCutsR[nCutsR]->Sign = Lf_CutGetSign(pCutsR[nCutsR]);
            if ( p->pPars->nLutSizeMux && p->pPars->nLutSizeMux == (int)pCutsR[nCutsR]->nLeaves && 
                Lf_ManFindCofVar(Lf_CutTruth(p,pCutsR[nCutsR]), Abc_Truth6WordNum(nLutSize), pCutsR[nCutsR]->nLeaves) == -1 )
                continue;
            Lf_CutParams( p, pCutsR[nCutsR], Required, FlowRefs, pObj );
            nCutsR = Lf_SetAddCut( pCutsR, nCutsR, nCutNum );
        }
    }
    // debug printout
    if ( 0 )
    {
        printf( "*** Obj = %d  FlowRefs = %.2f  MapRefs = %2d  Required = %2d\n", iObj, FlowRefs, Lf_ObjMapRefNum(p, iObj), Required );
        for ( i = 0; i < nCutsR; i++ )
            Lf_CutPrint( p, pCutsR[i] );
        printf( "\n" );
    }
    // verify
    assert( nCutsR > 0 && nCutsR < nCutNum );
//    assert( Lf_SetCheckArray(pCutsR, nCutsR) );
    // delay cut
    assert( nCutsR == 1 || pCutsR[0]->Delay <= pCutsR[1]->Delay );
    pBest->Cut[0].fUsed = pBest->Cut[1].fUsed = 0;
    pBest->Cut[0].Handle = pBest->Cut[1].Handle = Lf_MemSaveCut(&p->vStoreNew, pCutsR[0], iObj);
    pBest->Delay[0] = pBest->Delay[1] = pCutsR[0]->Delay;
    pBest->Flow[0] = pBest->Flow[1] = pCutsR[0]->Flow;
    p->nCutCounts[pCutsR[0]->nLeaves]++;
    p->CutCount[3] += nCutsR;
    p->nCutEqual++;
    // area cut
    iCutUsed = 0;
    if ( nCutsR > 1 && pCutsR[0]->Flow > pCutsR[1]->Flow + LF_EPSILON )//&& !pCutsR[1]->fLate ) // can remove !fLate
    {
        pBest->Cut[1].Handle = Lf_MemSaveCut(&p->vStoreNew, pCutsR[1], iObj);
        pBest->Delay[1] = pCutsR[1]->Delay;
        pBest->Flow[1] = pCutsR[1]->Flow;
        p->nCutCounts[pCutsR[1]->nLeaves]++;
        p->nCutEqual--;
        if ( !pCutsR[1]->fLate )
            iCutUsed = 1;
    }
    // mux cut
    if ( p->pPars->fUseMux7 && Gia_ObjIsMuxId(p->pGia, iObj) )
    {
        pCut2 = Lf_ObjCutMux( p, iObj );
        Lf_CutParams( p, pCut2, Required, FlowRefs, pObj );
        pBest->Delay[2] = pCut2->Delay;
        pBest->Flow[2] = pCut2->Flow;
        // update area value of the best area cut
//        if ( !pCut2->fLate )
//            pBest->Flow[1] = Abc_MinFloat( pBest->Flow[1], pBest->Flow[2] );
    }
    // reference resulting cut
    if ( p->fUseEla )
    {
        pBest->Cut[iCutUsed].fUsed = 1;
        if ( Lf_ObjMapRefNum(p, iObj) > 0 )
            Value2 = Lf_CutRef_rec( p, pCutsR[iCutUsed] );
//        if ( Value1 < Value2 )
//            printf( "ELA degradated cost at node %d from %d to %d.\n", iObj, Value1, Value2 ), fflush(stdout);
//        assert( Value1 >= Value2 );
//        if ( Value1 != -1 )
//            printf( "%.2f -> %.2f    ", Value1, Value2 );
    }
    if ( pObj->Value == 0 )
        return;
    // store the cutset
    pCutSet = Lf_ManFetchSet(p, iObj);
    Lf_CutSetForEachCut( nCutWords, pCutSet, pCut0, i, nCutNum )
    {
        assert( !pCut0->fMux7 );
        if ( i < nCutsR )
            Lf_CutCopy( pCut0, pCutsR[i], nCutWords );
        else if ( i == nCutsR && pCutsR[0]->nLeaves > 1 && (nCutsR == 1 || pCutsR[1]->nLeaves > 1) )
            Lf_CutCreateUnit( pCut0, iObj );
        else
            pCut0->nLeaves = LF_NO_LEAF;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ LF_CUT_MAX

◆ LF_CUT_WORDS

◆ Lf_CutForEachVar

◆ Lf_CutSetForEachCut

◆ LF_EPSILON

◆ LF_LEAF_MAX

◆ LF_LOG_PAGE

◆ LF_NO_LEAF

◆ LF_TT_WORDS

Typedef Documentation

◆ Lf_Bst_t

◆ Lf_Cut_t

◆ Lf_Man_t

◆ Lf_Mem_t

◆ Lf_Plc_t

Function Documentation

◆ Gia_ManPerformLfMapping()

◆ Kit_TruthToGia()

◆ Lf_CutDeref_rec()

◆ Lf_CutRef_rec()

◆ Lf_ManAlloc()

◆ Lf_ManAnalyzeCoDrivers()

◆ Lf_ManComputeCrossCut()

◆ Lf_ManComputeMapping()

◆ Lf_ManComputeSwitching()

◆ Lf_ManCountMapRefs()

◆ Lf_ManCountMapRefsOne()

◆ Lf_ManDeriveMapping()

◆ Lf_ManDeriveMappingCoarse()

◆ Lf_ManDeriveMappingGia()

◆ Lf_ManFree()

◆ Lf_ManPerformMapping()

◆ Lf_ManPerformMappingInt()

◆ Lf_ManPrintInit()

◆ Lf_ManPrintQuit()

◆ Lf_ManPrintStats()

◆ Lf_ManSetCutRefs()

◆ Lf_ManSetDefaultPars()

◆ Lf_ManSetFlowRefs()

◆ Lf_ManSetMapRefs()

◆ Lf_ManSetMapRefsOne()

◆ Lf_ManTtIsMux()

◆ Lf_ObjArrival_rec()

◆ Lf_ObjCoArrival2_rec()

◆ Lf_ObjMergeOrder()