#include "base/abc/abc.h"

Include dependency graph for abcOdc.c:

Classes
struct	Odc_Obj_t_

struct	Odc_Man_t_

Macros
#define	ABC_DC_MAX_NODES (1<<15)
	DECLARATIONS ///.

#define	Odc_ForEachPi(p, Lit, i)

#define	Odc_ForEachAnd(p, pObj, i)

Typedefs
typedef unsigned short	Odc_Lit_t

typedef struct Odc_Obj_t_	Odc_Obj_t

Functions
Odc_Man_t *	Abc_NtkDontCareAlloc (int nVarsMax, int nLevels, int fVerbose, int fVeryVerbose)
	FUNCTION DEFINITIONS ///.

void	Abc_NtkDontCareClear (Odc_Man_t *p)

void	Abc_NtkDontCareFree (Odc_Man_t *p)

void	Abc_NtkDontCareWinSweepLeafTfo_rec (Abc_Obj_t pObj, int nLevelLimit, Abc_Obj_t pNode)

void	Abc_NtkDontCareWinSweepLeafTfo (Odc_Man_t *p)

void	Abc_NtkDontCareWinCollectRoots_rec (Abc_Obj_t pObj, Vec_Ptr_t vRoots)

void	Abc_NtkDontCareWinCollectRoots (Odc_Man_t *p)

int	Abc_NtkDontCareWinAddMissing_rec (Odc_Man_t p, Abc_Obj_t pObj)

int	Abc_NtkDontCareWinAddMissing (Odc_Man_t *p)

int	Abc_NtkDontCareWindow (Odc_Man_t *p)

void *	Abc_NtkDontCareTransfer_rec (Odc_Man_t p, Abc_Obj_t pNode, Abc_Obj_t *pPivot)

int	Abc_NtkDontCareTransfer (Odc_Man_t *p)

unsigned	Abc_NtkDontCareCofactors_rec (Odc_Man_t *p, Odc_Lit_t Lit, unsigned uMask)

int	Abc_NtkDontCareQuantify (Odc_Man_t *p)

void	Abc_NtkDontCareSimulateSetElem2 (Odc_Man_t *p)

void	Abc_NtkDontCareSimulateSetElem (Odc_Man_t *p)

void	Abc_NtkDontCareSimulateSetRand (Odc_Man_t *p)

int	Abc_NtkDontCareCountMintsWord (Odc_Man_t p, unsigned puTruth)

void	Abc_NtkDontCareTruthOne (Odc_Man_t *p, Odc_Lit_t Lit)

void	Abc_NtkDontCareSimulate_rec (Odc_Man_t *p, Odc_Lit_t Lit)

int	Abc_NtkDontCareSimulate (Odc_Man_t p, unsigned puTruth)

int	Abc_NtkDontCareSimulateBefore (Odc_Man_t p, unsigned puTruth)

int	Abc_NtkDontCareCompute (Odc_Man_t p, Abc_Obj_t pNode, Vec_Ptr_t vLeaves, unsigned puTruth)

Macro Definition Documentation

◆ ABC_DC_MAX_NODES

#define ABC_DC_MAX_NODES (1<<15)

DECLARATIONS ///.

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

FileName [abcOdc.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Scalable computation of observability don't-cares.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 30 of file abcOdc.c.

◆ Odc_ForEachAnd

#define Odc_ForEachAnd	(	p,
		pObj,
		i )

Value:

for ( i = 1 + Odc_CiNum(p); (i < Odc_ObjNum(p)) && ((pObj) = (p)->pObjs + i); i++ )

p

Cube * p

Definition exorList.c:222

Definition at line 143 of file abcOdc.c.

143#define Odc_ForEachAnd( p, pObj, i ) \

144 for ( i = 1 + Odc_CiNum(p); (i < Odc_ObjNum(p)) && ((pObj) = (p)->pObjs + i); i++ )

◆ Odc_ForEachPi

#define Odc_ForEachPi	(	p,
		Lit,
		i )

Value:

for ( i = 0; (i < Odc_PiNum(p)) && (((Lit) = Odc_Var(p, i)), 1); i++ )

Definition at line 141 of file abcOdc.c.

141#define Odc_ForEachPi( p, Lit, i ) \

142 for ( i = 0; (i < Odc_PiNum(p)) && (((Lit) = Odc_Var(p, i)), 1); i++ )

Typedef Documentation

◆ Odc_Lit_t

typedef unsigned short Odc_Lit_t

Definition at line 32 of file abcOdc.c.

◆ Odc_Obj_t

typedef struct Odc_Obj_t_ Odc_Obj_t

Definition at line 34 of file abcOdc.c.

Function Documentation

◆ Abc_NtkDontCareAlloc()

Odc_Man_t * Abc_NtkDontCareAlloc	(	int	nVarsMax,
		int	nLevels,
		int	fVerbose,
		int	fVeryVerbose )

FUNCTION DEFINITIONS ///.

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

Synopsis [Allocates the don't-care manager.]

Description [The parameters are the max number of cut variables, the number of fanout levels used for the ODC computation, and verbosiness.]

SideEffects []

SeeAlso []

Definition at line 163 of file abcOdc.c.

{
    Odc_Man_t * p;
    unsigned * pData;
    int i, k;
    p = ABC_ALLOC( Odc_Man_t, 1 );
    memset( p, 0, sizeof(Odc_Man_t) );
    assert( nVarsMax > 4 && nVarsMax < 16 );
    assert( nLevels > 0 && nLevels < 10 );
 
    srand( 0xABC );
 
    // dont'-care parameters
    p->nVarsMax     = nVarsMax;
    p->nLevels      = nLevels;
    p->fVerbose     = fVerbose;
    p->fVeryVerbose = fVeryVerbose;
    p->nPercCutoff  = 10;
    p->skipQuant    = 0;
 
    // windowing
    p->vRoots    = Vec_PtrAlloc( 128 );
    p->vBranches = Vec_PtrAlloc( 128 );
 
    // internal AIG package
    // allocate room for objects
    p->nObjsAlloc = ABC_DC_MAX_NODES; 
    p->pObjs = ABC_ALLOC( Odc_Obj_t, p->nObjsAlloc * sizeof(Odc_Obj_t) );
    p->nPis  = nVarsMax + 32;
    p->nObjs = 1 + p->nPis;
    memset( p->pObjs, 0, p->nObjs * sizeof(Odc_Obj_t) );
    // set the PI masks
    for ( i = 0; i < 32; i++ )
        p->pObjs[1 + p->nVarsMax + i].uMask = (1 << i);
    // allocate hash table
    p->nTableSize = p->nObjsAlloc/3 + 1;
    p->pTable = ABC_ALLOC( Odc_Lit_t, p->nTableSize * sizeof(Odc_Lit_t) );
    memset( p->pTable, 0, p->nTableSize * sizeof(Odc_Lit_t) );
    p->vUsedSpots = Vec_IntAlloc( 1000 );
 
    // truth tables
    p->nWords = Abc_TruthWordNum( p->nVarsMax );
    p->nBits = p->nWords * 8 * sizeof(unsigned);
    p->vTruths = Vec_PtrAllocSimInfo( p->nObjsAlloc, p->nWords );
    p->vTruthsElem = Vec_PtrAllocSimInfo( p->nVarsMax, p->nWords );
 
    // set elementary truth tables
    Abc_InfoFill( (unsigned *)Vec_PtrEntry(p->vTruths, 0), p->nWords );
    for ( k = 0; k < p->nVarsMax; k++ )
    {
//        pData = Odc_ObjTruth( p, Odc_Var(p, k) );
        pData = (unsigned *)Vec_PtrEntry( p->vTruthsElem, k );
        Abc_InfoClear( pData, p->nWords );
        for ( i = 0; i < p->nBits; i++ )
            if ( i & (1 << k) )
                pData[i>>5] |= (1 << (i&31));
    }
 
    // set random truth table for the additional inputs
    for ( k = p->nVarsMax; k < p->nPis; k++ )
    {
        pData = Odc_ObjTruth( p, Odc_Var(p, k) );
        Abc_InfoRandom( pData, p->nWords );
    }
 
    // set the miter to the unused value
    p->iRoot = 0xffff;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareClear()

void Abc_NtkDontCareClear ( Odc_Man_t * p )

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

Synopsis [Clears the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 244 of file abcOdc.c.

{
    abctime clk = Abc_Clock();
    // clean the structural hashing table
    if ( Vec_IntSize(p->vUsedSpots) > p->nTableSize/3 ) // more than one third
        memset( p->pTable, 0, sizeof(Odc_Lit_t) * p->nTableSize );
    else
    {
        int iSpot, i;
        Vec_IntForEachEntry( p->vUsedSpots, iSpot, i )
            p->pTable[iSpot] = 0;
    }
    Vec_IntClear( p->vUsedSpots ); 
    // reset the number of nodes
    p->nObjs = 1 + p->nPis;
    // reset the root node
    p->iRoot = 0xffff;
 
p->timeClean += Abc_Clock() - clk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareCofactors_rec()

unsigned Abc_NtkDontCareCofactors_rec	(	Odc_Man_t *	p,
		Odc_Lit_t	Lit,
		unsigned	uMask )

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

Synopsis [Recursively computes the pair of cofactors.]

Description []

SideEffects []

SeeAlso []

Definition at line 740 of file abcOdc.c.

{
    Odc_Obj_t * pObj;
    unsigned uData0, uData1;
    Odc_Lit_t uLit0, uLit1, uRes0, uRes1;
    assert( !Odc_IsComplement(Lit) );
    // skip visited objects
    pObj = Odc_Lit2Obj( p, Lit );
    if ( Odc_ObjIsTravIdCurrent(p, pObj) )
    {
        p->skipQuant = 1;
        return pObj->uData;
    }
    Odc_ObjSetTravIdCurrent(p, pObj);
    // skip objects out of the cone
    if ( (pObj->uMask & uMask) == 0 )
        return pObj->uData = ((Lit << 16) | Lit);
    // consider the case when the node is the var
    if ( pObj->uMask == uMask && Odc_IsTerm(p, Lit) )
        return pObj->uData = ((Odc_Const1() << 16) | Odc_Const0());
    // compute the cofactors
    uData0 = Abc_NtkDontCareCofactors_rec( p, Odc_ObjFanin0(pObj), uMask );
    uData1 = Abc_NtkDontCareCofactors_rec( p, Odc_ObjFanin1(pObj), uMask );
    // find the 0-cofactor
    uLit0 = Odc_NotCond( (Odc_Lit_t)(uData0 & 0xffff), Odc_ObjFaninC0(pObj) );
    uLit1 = Odc_NotCond( (Odc_Lit_t)(uData1 & 0xffff), Odc_ObjFaninC1(pObj) );
    uRes0 = Odc_And( p, uLit0, uLit1 );
    // find the 1-cofactor
    uLit0 = Odc_NotCond( (Odc_Lit_t)(uData0 >> 16), Odc_ObjFaninC0(pObj) );
    uLit1 = Odc_NotCond( (Odc_Lit_t)(uData1 >> 16), Odc_ObjFaninC1(pObj) );
    uRes1 = Odc_And( p, uLit0, uLit1 );
    // find the result
    p->skipQuant = 0;
    return pObj->uData = ((uRes1 << 16) | uRes0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareCompute()

int Abc_NtkDontCareCompute	(	Odc_Man_t *	p,
		Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vLeaves,
		unsigned *	puTruth )

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

Synopsis [Computes ODCs for the node in terms of the cut variables.]

Description [Returns the number of don't care minterms in the truth table. In particular, this procedure returns 0 if there is no don't-cares.]

SideEffects []

SeeAlso []

Definition at line 1042 of file abcOdc.c.

{
    int nMints, RetValue;
    abctime clk, clkTotal = Abc_Clock();
 
    p->nWins++;
    
    // set the parameters
    assert( !Abc_ObjIsComplement(pNode) );
    assert( Abc_ObjIsNode(pNode) );
    assert( Vec_PtrSize(vLeaves) <= p->nVarsMax );
    p->vLeaves = vLeaves;
    p->pNode = pNode;
 
    // compute the window
clk = Abc_Clock();
    RetValue = Abc_NtkDontCareWindow( p );
p->timeWin += Abc_Clock() - clk;
    if ( !RetValue )
    {
p->timeAbort += Abc_Clock() - clkTotal;
        Abc_InfoFill( puTruth, p->nWords );
        p->nWinsEmpty++;        
        return 0;
    }
 
    if ( p->fVeryVerbose )
    {
        printf( " %5d : ", pNode->Id );
        printf( "Leaf = %2d ", Vec_PtrSize(p->vLeaves) );
        printf( "Root = %2d ", Vec_PtrSize(p->vRoots) );
        printf( "Bran = %2d ", Vec_PtrSize(p->vBranches) );
        printf( " |  " );
    }
 
    // transfer the window into the AIG package
clk = Abc_Clock();
    Abc_NtkDontCareTransfer( p );
p->timeMiter += Abc_Clock() - clk;
 
    // simulate to estimate the amount of don't-cares
clk = Abc_Clock();
    nMints = Abc_NtkDontCareSimulateBefore( p, puTruth );
p->timeSim += Abc_Clock() - clk;
    if ( p->fVeryVerbose )
    {
        printf( "AIG = %5d ", Odc_NodeNum(p) );
        printf( "%6.2f %%  ", 100.0 * (p->nBits - nMints) / p->nBits );
    }
 
    // if there is less then the given percentage of don't-cares, skip
    if ( 100.0 * (p->nBits - nMints) / p->nBits < 1.0 * p->nPercCutoff )
    {
p->timeAbort += Abc_Clock() - clkTotal;
        if ( p->fVeryVerbose )
            printf( "Simulation cutoff.\n" );
        Abc_InfoFill( puTruth, p->nWords );
        p->nSimsEmpty++;
        return 0;
    }
 
    // quantify external variables
clk = Abc_Clock();
    RetValue = Abc_NtkDontCareQuantify( p );
p->timeQuant += Abc_Clock() - clk;
    if ( !RetValue )
    {
p->timeAbort += Abc_Clock() - clkTotal;
        if ( p->fVeryVerbose )
            printf( "=== Overflow! ===\n" );
        Abc_InfoFill( puTruth, p->nWords );
        p->nQuantsOver++;
        return 0;
    }
 
    // get the truth table
clk = Abc_Clock();
    Abc_NtkDontCareSimulateSetElem( p );
    nMints = Abc_NtkDontCareSimulate( p, puTruth );
p->timeTruth += Abc_Clock() - clk;
    if ( p->fVeryVerbose )
    {
        printf( "AIG = %5d ", Odc_NodeNum(p) );
        printf( "%6.2f %%  ", 100.0 * (p->nBits - nMints) / p->nBits );
        printf( "\n" );
    }
p->timeTotal += Abc_Clock() - clkTotal;
    p->nWinsFinish++;
    p->nTotalDcs += (int)(100.0 * (p->nBits - nMints) / p->nBits);
    return nMints;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareCountMintsWord()

int Abc_NtkDontCareCountMintsWord	(	Odc_Man_t *	p,
		unsigned *	puTruth )

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

Synopsis [Set random simulation words for PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 901 of file abcOdc.c.

{
    int w, Counter = 0;
    for ( w = 0; w < p->nWords; w++ )
        if ( puTruth[w] )
            Counter++;
    return Counter;
}

Here is the caller graph for this function:

◆ Abc_NtkDontCareFree()

void Abc_NtkDontCareFree ( Odc_Man_t * p )

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

Synopsis [Frees the don't-care manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 276 of file abcOdc.c.

{
    if ( p->fVerbose )
    {
        printf( "Wins = %5d. Empty = %5d. SimsEmpty = %5d. QuantOver = %5d. WinsFinish = %5d.\n", 
            p->nWins, p->nWinsEmpty, p->nSimsEmpty, p->nQuantsOver, p->nWinsFinish );
        printf( "Ave DCs per window = %6.2f %%. Ave DCs per finished window = %6.2f %%.\n", 
            1.0*p->nTotalDcs/p->nWins, 1.0*p->nTotalDcs/p->nWinsFinish );
        printf( "Runtime stats of the ODC manager:\n" );
        ABC_PRT( "Cleaning    ", p->timeClean );
        ABC_PRT( "Windowing   ", p->timeWin   );
        ABC_PRT( "Miter       ", p->timeMiter );
        ABC_PRT( "Simulation  ", p->timeSim   );
        ABC_PRT( "Quantifying ", p->timeQuant );
        ABC_PRT( "Truth table ", p->timeTruth );
        ABC_PRT( "TOTAL       ", p->timeTotal );
        ABC_PRT( "Aborted     ", p->timeAbort );
    }
    Vec_PtrFree( p->vRoots );
    Vec_PtrFree( p->vBranches );
    Vec_PtrFree( p->vTruths );
    Vec_PtrFree( p->vTruthsElem );
    Vec_IntFree( p->vUsedSpots );
    ABC_FREE( p->pObjs );
    ABC_FREE( p->pTable );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Abc_NtkDontCareQuantify()

int Abc_NtkDontCareQuantify ( Odc_Man_t * p )

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

Synopsis [Quantifies the branch variables.]

Description []

SideEffects []

SeeAlso []

Definition at line 787 of file abcOdc.c.

{   
    Odc_Lit_t uRes0, uRes1;
    unsigned uData;
    int i;
    p->skipQuant = 0;
    assert( p->iRoot < 0xffff );
    assert( Vec_PtrSize(p->vBranches) <= 32 ); // the mask size
    for ( i = 0; i < Vec_PtrSize(p->vBranches); i++ )
    {
        // compute the cofactors w.r.t. this variable
        Odc_ManIncrementTravId( p );
        uData = Abc_NtkDontCareCofactors_rec( p, Odc_Regular(p->iRoot), (1 << i) );
        if ( p->skipQuant ) 
            continue;
        uRes0 = Odc_NotCond( (Odc_Lit_t)(uData & 0xffff), Odc_IsComplement(p->iRoot) );
        uRes1 = Odc_NotCond( (Odc_Lit_t)(uData >> 16),    Odc_IsComplement(p->iRoot) );
        // quantify this variable existentially
        p->iRoot = Odc_Or( p, uRes0, uRes1 );
        // check the limit
        if ( Odc_ObjNum(p) > ABC_DC_MAX_NODES/2 )
            return 0;
    }
    assert( p->nObjs <= p->nObjsAlloc );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareSimulate()

int Abc_NtkDontCareSimulate	(	Odc_Man_t *	p,
		unsigned *	puTruth )

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

Synopsis [Computes the truth table of the care set.]

Description [Returns the number of ones in the simulation info.]

SideEffects []

SeeAlso []

Definition at line 991 of file abcOdc.c.

{
    Odc_ManIncrementTravId( p );
    Abc_NtkDontCareSimulate_rec( p, Odc_Regular(p->iRoot) );
    Abc_InfoCopy( puTruth, Odc_ObjTruth(p, Odc_Regular(p->iRoot)), p->nWords );
    if ( Odc_IsComplement(p->iRoot) )
        Abc_InfoNot( puTruth, p->nWords );
    return Extra_TruthCountOnes( puTruth, p->nVarsMax );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareSimulate_rec()

void Abc_NtkDontCareSimulate_rec	(	Odc_Man_t *	p,
		Odc_Lit_t	Lit )

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

Synopsis [Computes the truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 961 of file abcOdc.c.

{
    Odc_Obj_t * pObj;
    assert( !Odc_IsComplement(Lit) );
    // skip terminals
    if ( Odc_IsTerm(p, Lit) )
        return;
    // skip visited objects
    pObj = Odc_Lit2Obj( p, Lit );
    if ( Odc_ObjIsTravIdCurrent(p, pObj) )
        return;
    Odc_ObjSetTravIdCurrent(p, pObj);
    // call recursively
    Abc_NtkDontCareSimulate_rec( p, Odc_ObjFanin0(pObj) );
    Abc_NtkDontCareSimulate_rec( p, Odc_ObjFanin1(pObj) );
    // construct the truth table
    Abc_NtkDontCareTruthOne( p, Lit );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareSimulateBefore()

int Abc_NtkDontCareSimulateBefore	(	Odc_Man_t *	p,
		unsigned *	puTruth )

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

Synopsis [Computes the truth table of the care set.]

Description [Returns the number of ones in the simulation info.]

SideEffects []

SeeAlso []

Definition at line 1012 of file abcOdc.c.

{
    int nIters = 2;
    int nRounds, Counter, r;
    // decide how many rounds to simulate
    nRounds = p->nBits / p->nWords;
    Counter = 0;
    for ( r = 0; r < nIters; r++ )
    {
        Abc_NtkDontCareSimulateSetRand( p );
        Abc_NtkDontCareSimulate( p, puTruth );
        Counter += Abc_NtkDontCareCountMintsWord( p, puTruth );
    }
    // normalize
    Counter = Counter * nRounds / nIters;
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareSimulateSetElem()

void Abc_NtkDontCareSimulateSetElem ( Odc_Man_t * p )

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

Synopsis [Set elementary truth tables for PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 852 of file abcOdc.c.

{
    unsigned * pData, * pData2;
    int k;
    for ( k = 0; k < p->nVarsMax; k++ )
    {
        pData = Odc_ObjTruth( p, Odc_Var(p, k) );
        pData2 = (unsigned *)Vec_PtrEntry( p->vTruthsElem, k );
        Abc_InfoCopy( pData, pData2, p->nWords );
    }
}

Here is the caller graph for this function:

◆ Abc_NtkDontCareSimulateSetElem2()

void Abc_NtkDontCareSimulateSetElem2 ( Odc_Man_t * p )

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

Synopsis [Set elementary truth tables for PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 827 of file abcOdc.c.

{
    unsigned * pData;
    int i, k;
    for ( k = 0; k < p->nVarsMax; k++ )
    {
        pData = Odc_ObjTruth( p, Odc_Var(p, k) );
        Abc_InfoClear( pData, p->nWords );
        for ( i = 0; i < p->nBits; i++ )
            if ( i & (1 << k) )
                pData[i>>5] |= (1 << (i&31));
    }
}

◆ Abc_NtkDontCareSimulateSetRand()

void Abc_NtkDontCareSimulateSetRand ( Odc_Man_t * p )

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

Synopsis [Set random simulation words for PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 875 of file abcOdc.c.

{
    unsigned * pData;
    int w, k, Number;
    for ( w = 0; w < p->nWords; w++ )
    {
        Number = rand();
        for ( k = 0; k < p->nVarsMax; k++ )
        {
            pData = Odc_ObjTruth( p, Odc_Var(p, k) );
            pData[w] = (Number & (1<<k)) ? ~0 : 0;
        }
    }
}

Here is the caller graph for this function:

◆ Abc_NtkDontCareTransfer()

int Abc_NtkDontCareTransfer ( Odc_Man_t * p )

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

Synopsis [Transfers the window into the AIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 690 of file abcOdc.c.

{
    Abc_Obj_t * pObj;
    Odc_Lit_t uRes0, uRes1;
    Odc_Lit_t uLit;
    unsigned uData;
    int i;
    Abc_NtkIncrementTravId( p->pNode->pNtk );
    // set elementary variables at the leaves 
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
    {
        uLit = Odc_Var( p, i );
        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)((uLit << 16) | uLit);
        Abc_NodeSetTravIdCurrent(pObj);
    }
    // set elementary variables at the branched 
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vBranches, pObj, i )
    {
        uLit = Odc_Var( p, i+p->nVarsMax );
        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)((uLit << 16) | uLit);
        Abc_NodeSetTravIdCurrent(pObj);
    }
    // compute the AIG for the window
    p->iRoot = Odc_Const0();
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
    {
        uData = (unsigned)(ABC_PTRUINT_T)Abc_NtkDontCareTransfer_rec( p, pObj, p->pNode );
        // get the cofactors
        uRes0 = uData & 0xffff;
        uRes1 = uData >> 16;
        // compute the miter
//        assert( uRes0 != uRes1 ); // may be false if the node is redundant w.r.t. this root
        uLit = Odc_Xor( p, uRes0, uRes1 );
        p->iRoot = Odc_Or( p, p->iRoot, uLit );
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareTransfer_rec()

void * Abc_NtkDontCareTransfer_rec	(	Odc_Man_t *	p,
		Abc_Obj_t *	pNode,
		Abc_Obj_t *	pPivot )

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

Synopsis [Transfers the window into the AIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 651 of file abcOdc.c.

{
    unsigned uData0, uData1;
    Odc_Lit_t uLit0, uLit1, uRes0, uRes1;
    assert( !Abc_ObjIsComplement(pNode) );
    // skip visited objects
    if ( Abc_NodeIsTravIdCurrent(pNode) )
        return pNode->pCopy;
    Abc_NodeSetTravIdCurrent(pNode);
    assert( Abc_ObjIsNode(pNode) );
    // consider the case when the node is the pivot
    if ( pNode == pPivot )
        return pNode->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)((Odc_Const1() << 16) | Odc_Const0());
    // compute the cofactors
    uData0 = (unsigned)(ABC_PTRUINT_T)Abc_NtkDontCareTransfer_rec( p, Abc_ObjFanin0(pNode), pPivot );
    uData1 = (unsigned)(ABC_PTRUINT_T)Abc_NtkDontCareTransfer_rec( p, Abc_ObjFanin1(pNode), pPivot );
    // find the 0-cofactor
    uLit0 = Odc_NotCond( (Odc_Lit_t)(uData0 & 0xffff), Abc_ObjFaninC0(pNode) );
    uLit1 = Odc_NotCond( (Odc_Lit_t)(uData1 & 0xffff), Abc_ObjFaninC1(pNode) );
    uRes0 = Odc_And( p, uLit0, uLit1 );
    // find the 1-cofactor
    uLit0 = Odc_NotCond( (Odc_Lit_t)(uData0 >> 16), Abc_ObjFaninC0(pNode) );
    uLit1 = Odc_NotCond( (Odc_Lit_t)(uData1 >> 16), Abc_ObjFaninC1(pNode) );
    uRes1 = Odc_And( p, uLit0, uLit1 );
    // find the result
    return pNode->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)((uRes1 << 16) | uRes0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareTruthOne()

void Abc_NtkDontCareTruthOne	(	Odc_Man_t *	p,
		Odc_Lit_t	Lit )

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

Synopsis [Simulates one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 921 of file abcOdc.c.

{
    Odc_Obj_t * pObj;
    unsigned * pInfo, * pInfo1, * pInfo2;
    int k, fComp1, fComp2;
    assert( !Odc_IsComplement( Lit ) );
    assert( !Odc_IsTerm( p, Lit ) );
    // get the truth tables
    pObj   = Odc_Lit2Obj( p, Lit );
    pInfo  = Odc_ObjTruth( p, Lit );
    pInfo1 = Odc_ObjTruth( p, Odc_ObjFanin0(pObj) );
    pInfo2 = Odc_ObjTruth( p, Odc_ObjFanin1(pObj) );
    fComp1 = Odc_ObjFaninC0( pObj );
    fComp2 = Odc_ObjFaninC1( pObj );
    // simulate
    if ( fComp1 && fComp2 )
        for ( k = 0; k < p->nWords; k++ )
            pInfo[k] = ~pInfo1[k] & ~pInfo2[k];
    else if ( fComp1 && !fComp2 )
        for ( k = 0; k < p->nWords; k++ )
            pInfo[k] = ~pInfo1[k] &  pInfo2[k];
    else if ( !fComp1 && fComp2 )
        for ( k = 0; k < p->nWords; k++ )
            pInfo[k] =  pInfo1[k] & ~pInfo2[k];
    else // if ( fComp1 && fComp2 )
        for ( k = 0; k < p->nWords; k++ )
            pInfo[k] =  pInfo1[k] &  pInfo2[k];
}

Here is the caller graph for this function:

◆ Abc_NtkDontCareWinAddMissing()

int Abc_NtkDontCareWinAddMissing ( Odc_Man_t * p )

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

Synopsis [Adds to the window nodes and leaves in the TFI of the roots.]

Description []

SideEffects []

SeeAlso []

Definition at line 452 of file abcOdc.c.

{
    Abc_Obj_t * pObj;
    int i;
    // set the leaves
    Abc_NtkIncrementTravId( p->pNode->pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
        Abc_NodeSetTravIdCurrent( pObj );        
    // explore from the roots
    Vec_PtrClear( p->vBranches );
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
        if ( !Abc_NtkDontCareWinAddMissing_rec( p, pObj ) )
            return 0;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareWinAddMissing_rec()

int Abc_NtkDontCareWinAddMissing_rec	(	Odc_Man_t *	p,
		Abc_Obj_t *	pObj )

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

Synopsis [Recursively adds missing nodes and leaves.]

Description []

SideEffects []

SeeAlso []

Definition at line 420 of file abcOdc.c.

{
    Abc_Obj_t * pFanin;
    int i;
    // skip the already collected leaves and branches
    if ( Abc_NodeIsTravIdCurrent(pObj) )
        return 1;
    // if this is not an internal node - make it a new branch
    if ( !Abc_NodeIsTravIdPrevious(pObj) || Abc_ObjIsCi(pObj) ) //|| (int)pObj->Level <= p->nLevLeaves )
    {
        Abc_NodeSetTravIdCurrent( pObj );
        Vec_PtrPush( p->vBranches, pObj );
        return Vec_PtrSize(p->vBranches) <= 32;
    }
    // visit the fanins of the node
    Abc_ObjForEachFanin( pObj, pFanin, i )
        if ( !Abc_NtkDontCareWinAddMissing_rec( p, pFanin ) )
            return 0;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareWinCollectRoots()

void Abc_NtkDontCareWinCollectRoots ( Odc_Man_t * p )

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

Synopsis [Collects the roots of the window.]

Description [Roots of the window are the nodes that have at least one fanout that it not in the TFO of the leaves.]

SideEffects []

SeeAlso []

Definition at line 399 of file abcOdc.c.

{
    assert( !Abc_NodeIsTravIdCurrent(p->pNode) );
    // mark the node with the old traversal ID
    Abc_NodeSetTravIdCurrent( p->pNode ); 
    // collect the roots
    Vec_PtrClear( p->vRoots );
    Abc_NtkDontCareWinCollectRoots_rec( p->pNode, p->vRoots );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareWinCollectRoots_rec()

void Abc_NtkDontCareWinCollectRoots_rec	(	Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vRoots )

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

Synopsis [Recursively collects the roots.]

Description []

SideEffects []

SeeAlso []

Definition at line 366 of file abcOdc.c.

{
    Abc_Obj_t * pFanout;
    int i;
    assert( Abc_ObjIsNode(pObj) );
    assert( Abc_NodeIsTravIdCurrent(pObj) );
    // check if the node has all fanouts marked
    Abc_ObjForEachFanout( pObj, pFanout, i )
        if ( !Abc_NodeIsTravIdCurrent(pFanout) )
            break;
    // if some of the fanouts are unmarked, add the node to the root
    if ( i < Abc_ObjFanoutNum(pObj) ) 
    {
        Vec_PtrPushUnique( vRoots, pObj );
        return;
    }
    // otherwise, call recursively
    Abc_ObjForEachFanout( pObj, pFanout, i )
        Abc_NtkDontCareWinCollectRoots_rec( pFanout, vRoots );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareWindow()

int Abc_NtkDontCareWindow ( Odc_Man_t * p )

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

Synopsis [Computes window for the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 479 of file abcOdc.c.

{
    // mark the TFO of the collected nodes up to the given level (p->pNode->Level + p->nWinTfoMax)
    Abc_NtkDontCareWinSweepLeafTfo( p );
    // find the roots of the window
    Abc_NtkDontCareWinCollectRoots( p );
    if ( Vec_PtrSize(p->vRoots) == 1 && Vec_PtrEntry(p->vRoots, 0) == p->pNode )
    {
//        printf( "Empty window\n" );
        return 0;
    }
    // add the nodes in the TFI of the roots that are not yet in the window
    if ( !Abc_NtkDontCareWinAddMissing( p ) )
    {
//        printf( "Too many branches (%d)\n", Vec_PtrSize(p->vBranches) );
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareWinSweepLeafTfo()

void Abc_NtkDontCareWinSweepLeafTfo ( Odc_Man_t * p )

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

Synopsis [Marks the TFO of the collected nodes up to the given level.]

Description []

SideEffects []

SeeAlso []

Definition at line 346 of file abcOdc.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkIncrementTravId( p->pNode->pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
        Abc_NtkDontCareWinSweepLeafTfo_rec( pObj, p->pNode->Level + p->nLevels, p->pNode );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareWinSweepLeafTfo_rec()

void Abc_NtkDontCareWinSweepLeafTfo_rec	(	Abc_Obj_t *	pObj,
		int	nLevelLimit,
		Abc_Obj_t *	pNode )

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

Synopsis [Marks the TFO of the collected nodes up to the given level.]

Description []

SideEffects []

SeeAlso []

Definition at line 317 of file abcOdc.c.

{
    Abc_Obj_t * pFanout;
    int i;
    if ( Abc_ObjIsCo(pObj) || (int)pObj->Level > nLevelLimit || pObj == pNode )
        return;
    if ( Abc_NodeIsTravIdCurrent(pObj) )
        return;
    Abc_NodeSetTravIdCurrent( pObj );
    // try to reduce the runtime
    if ( Abc_ObjFanoutNum(pObj) > 100 )
        return;
    Abc_ObjForEachFanout( pObj, pFanout, i )
        Abc_NtkDontCareWinSweepLeafTfo_rec( pFanout, nLevelLimit, pNode );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ ABC_DC_MAX_NODES

◆ Odc_ForEachAnd

◆ Odc_ForEachPi

Typedef Documentation

◆ Odc_Lit_t

◆ Odc_Obj_t

Function Documentation

◆ Abc_NtkDontCareAlloc()

◆ Abc_NtkDontCareClear()

◆ Abc_NtkDontCareCofactors_rec()

◆ Abc_NtkDontCareCompute()

◆ Abc_NtkDontCareCountMintsWord()

◆ Abc_NtkDontCareFree()

◆ Abc_NtkDontCareQuantify()

◆ Abc_NtkDontCareSimulate()

◆ Abc_NtkDontCareSimulate_rec()

◆ Abc_NtkDontCareSimulateBefore()

◆ Abc_NtkDontCareSimulateSetElem()

◆ Abc_NtkDontCareSimulateSetElem2()

◆ Abc_NtkDontCareSimulateSetRand()

◆ Abc_NtkDontCareTransfer()

◆ Abc_NtkDontCareTransfer_rec()

◆ Abc_NtkDontCareTruthOne()

◆ Abc_NtkDontCareWinAddMissing()

◆ Abc_NtkDontCareWinAddMissing_rec()

◆ Abc_NtkDontCareWinCollectRoots()

◆ Abc_NtkDontCareWinCollectRoots_rec()

◆ Abc_NtkDontCareWindow()

◆ Abc_NtkDontCareWinSweepLeafTfo()

◆ Abc_NtkDontCareWinSweepLeafTfo_rec()