abcLut.c File Reference

#include "base/abc/abc.h"
#include "opt/cut/cut.h"

Include dependency graph for abcLut.c:

Go to the source code of this file.

Classes
struct	Abc_ManScl_t_

Macros
#define	LARGE_LEVEL   1000000
#define	SCL_LUT_MAX   6
	DECLARATIONS ///.
#define	SCL_VARS_MAX   15
#define	SCL_NODE_MAX   1000

Typedefs
typedef struct Abc_ManScl_t_	Abc_ManScl_t

Functions
int	Abc_NtkSuperChoiceLut (Abc_Ntk_t *pNtk, int nLutSize, int nCutSizeMax, int fVerbose)
	FUNCTION DEFINITIONS ///.
unsigned *	Abc_NodeSuperChoiceTruth (Abc_ManScl_t *pManScl)
void	Abc_NodeSuperChoiceCollect2_rec (Abc_Obj_t *pObj, Vec_Ptr_t *vVolume)
void	Abc_NodeSuperChoiceCollect2 (Abc_Obj_t *pRoot, Vec_Ptr_t *vLeaves, Vec_Ptr_t *vVolume)
void	Abc_NodeSuperChoiceCollect_rec (Abc_Obj_t *pObj, Vec_Ptr_t *vLeaves, Vec_Ptr_t *vVolume)
void	Abc_NodeSuperChoiceCollect (Abc_Obj_t *pRoot, Vec_Ptr_t *vLeaves, Vec_Ptr_t *vVolume)
void	Abc_NodeLeavesRemove (Vec_Ptr_t *vLeaves, unsigned uPhase, int nVars)
int	Abc_NodeGetLevel (Abc_Obj_t *pObj)
int	Abc_NodeCompareLevelsInc (int *pp1, int *pp2)
void	Abc_NodeDecomposeSort (Abc_Obj_t **pLeaves, int nVars, int *pBSet, int nLutSize)
word	Abc_ObjComputeTruth (Abc_Obj_t *pObj, Vec_Int_t *vSupp)
Abc_Obj_t *	Abc_NtkSpecialMap_rec (Abc_Ntk_t *pNew, Abc_Obj_t *pObj, Vec_Wec_t *vSupps, Vec_Int_t *vCover)
Abc_Ntk_t *	Abc_NtkSpecialMapping (Abc_Ntk_t *pNtk, int fVerbose)

Macro Definition Documentation

LARGE_LEVEL

#define LARGE_LEVEL   1000000

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

FileName [abcLut.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Superchoicing for K-LUTs.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 26 of file abcLut.c.

SCL_LUT_MAX

#define SCL_LUT_MAX   6

DECLARATIONS ///.

Definition at line 32 of file abcLut.c.

SCL_NODE_MAX

#define SCL_NODE_MAX   1000

Definition at line 34 of file abcLut.c.

SCL_VARS_MAX

#define SCL_VARS_MAX   15

Definition at line 33 of file abcLut.c.

Typedef Documentation

Abc_ManScl_t

typedef struct Abc_ManScl_t_ Abc_ManScl_t

Definition at line 36 of file abcLut.c.

Function Documentation

Abc_NodeCompareLevelsInc()

int Abc_NodeCompareLevelsInc	(	int *	pp1,
		int *	pp2 )

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

Synopsis [Procedure used for sorting the nodes in increasing order of levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 601 of file abcLut.c.

{
    Abc_Obj_t * pNode1, * pNode2;
    pNode1 = (Abc_Obj_t *)Vec_PtrEntry(s_pLeaves, *pp1);
    pNode2 = (Abc_Obj_t *)Vec_PtrEntry(s_pLeaves, *pp2);
    if ( pNode1->Level < pNode2->Level )
        return -1;
    if ( pNode1->Level > pNode2->Level ) 
        return 1;
    return 0; 
}

Abc_NodeDecomposeSort()

void Abc_NodeDecomposeSort	(	Abc_Obj_t **	pLeaves,
		int	nVars,
		int *	pBSet,
		int	nLutSize )

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

Synopsis [Selects the earliest arriving nodes from the array.]

Description []

SideEffects []

SeeAlso []

Definition at line 624 of file abcLut.c.

{
    Abc_Obj_t * pTemp[SCL_VARS_MAX];
    int i, k, kBest, LevelMin;
    assert( nLutSize < nVars );
    assert( nVars <= SCL_VARS_MAX );
    // copy nodes into the internal storage
//    printf( "(" );
    for ( i = 0; i < nVars; i++ )
    {
        pTemp[i] = pLeaves[i];
//        printf( " %d", pLeaves[i]->Level );
    }
//    printf( " )\n" );
    // choose one node at a time
    for ( i = 0; i < nLutSize; i++ )
    {
        kBest = -1;
        LevelMin = LARGE_LEVEL;
        for ( k = 0; k < nVars; k++ )
            if ( pTemp[k] && LevelMin > (int)pTemp[k]->Level )
            {
                LevelMin = pTemp[k]->Level;
                kBest = k;
            }
        pBSet[i] = kBest;
        pTemp[kBest] = NULL;
    }
}

Abc_NodeGetLevel()

int Abc_NodeGetLevel

(

Abc_Obj_t *

pObj

)

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

Synopsis [Performs superchoicing for one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 512 of file abcLut.c.

{
    Abc_Obj_t * pFanin;
    int i, Level;
    Level = 0;
    Abc_ObjForEachFanin( pObj, pFanin, i )
        Level = Abc_MaxInt( Level, (int)pFanin->Level );
    return Level + 1;
}

Abc_NodeLeavesRemove()

void Abc_NodeLeavesRemove	(	Vec_Ptr_t *	vLeaves,
		unsigned	uPhase,
		int	nVars )

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

Synopsis [Performs superchoicing for one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 493 of file abcLut.c.

{
    int i;
    for ( i = nVars - 1; i >= 0; i-- )
        if ( uPhase & (1 << i) )
            Vec_PtrRemove( vLeaves, Vec_PtrEntry(vLeaves, i) );
}

Abc_NodeSuperChoiceCollect()

void Abc_NodeSuperChoiceCollect	(	Abc_Obj_t *	pRoot,
		Vec_Ptr_t *	vLeaves,
		Vec_Ptr_t *	vVolume )

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

Synopsis [Performs superchoicing for one node.]

Description [Orders the leaves topologically.]

SideEffects []

SeeAlso []

Definition at line 465 of file abcLut.c.

{
    Abc_Obj_t * pObj;
    int i, nLeaves;
    nLeaves = Vec_PtrSize(vLeaves);
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pObj, i )
        pObj->fMarkB = pObj->fMarkC = 1;
    Vec_PtrClear( vVolume );
    Vec_PtrClear( vLeaves );
    Abc_NodeSuperChoiceCollect_rec( pRoot, vLeaves, vVolume );
    assert( Vec_PtrSize(vLeaves) == nLeaves );
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pObj, i )
        pObj->fMarkC = 0;
    Vec_PtrForEachEntry( Abc_Obj_t *, vVolume, pObj, i )
        pObj->fMarkC = 0;
}

Here is the call graph for this function:

Abc_NodeSuperChoiceCollect2()

void Abc_NodeSuperChoiceCollect2	(	Abc_Obj_t *	pRoot,
		Vec_Ptr_t *	vLeaves,
		Vec_Ptr_t *	vVolume )

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

Synopsis [Performs superchoicing for one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 413 of file abcLut.c.

{
    Abc_Obj_t * pObj;
    int i;
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pObj, i )
        pObj->fMarkC = 1;
    Vec_PtrClear( vVolume );
    Abc_NodeSuperChoiceCollect2_rec( pRoot, vVolume );
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pObj, i )
        pObj->fMarkC = 0;
    Vec_PtrForEachEntry( Abc_Obj_t *, vVolume, pObj, i )
        pObj->fMarkC = 0;
}

Here is the call graph for this function:

Abc_NodeSuperChoiceCollect2_rec()

void Abc_NodeSuperChoiceCollect2_rec	(	Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vVolume )

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

Synopsis [Performs superchoicing for one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 391 of file abcLut.c.

{
    if ( pObj->fMarkC )
        return;
    pObj->fMarkC = 1;
    assert( Abc_ObjFaninNum(pObj) == 2 );
    Abc_NodeSuperChoiceCollect2_rec( Abc_ObjFanin0(pObj), vVolume );
    Abc_NodeSuperChoiceCollect2_rec( Abc_ObjFanin1(pObj), vVolume );
    Vec_PtrPush( vVolume, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodeSuperChoiceCollect_rec()

void Abc_NodeSuperChoiceCollect_rec	(	Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vLeaves,
		Vec_Ptr_t *	vVolume )

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

Synopsis [Performs superchoicing for one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 438 of file abcLut.c.

{
    if ( pObj->fMarkB )
    {
        Vec_PtrPush( vLeaves, pObj );
        pObj->fMarkB = 0;
    }
    if ( pObj->fMarkC )
        return;
    pObj->fMarkC = 1;
    assert( Abc_ObjFaninNum(pObj) == 2 );
    Abc_NodeSuperChoiceCollect_rec( Abc_ObjFanin0(pObj), vLeaves, vVolume );
    Abc_NodeSuperChoiceCollect_rec( Abc_ObjFanin1(pObj), vLeaves, vVolume );
    Vec_PtrPush( vVolume, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodeSuperChoiceTruth()

unsigned * Abc_NodeSuperChoiceTruth

(

Abc_ManScl_t *

pManScl

)

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

Synopsis [Performs superchoicing for one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 344 of file abcLut.c.

{
    Abc_Obj_t * pObj;
    unsigned * puData0, * puData1, * puData = NULL;
    char * pSop;
    int i, k;
    // set elementary truth tables
    Vec_PtrForEachEntry( Abc_Obj_t *, pManScl->vLeaves, pObj, i )
        pObj->pNext = (Abc_Obj_t *)pManScl->uVars[i];
    // compute truth tables for internal nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, pManScl->vVolume, pObj, i )
    {
        // set storage for the node's simulation info
        pObj->pNext = (Abc_Obj_t *)pManScl->uSims[i];
        // get pointer to the simulation info
        puData  = (unsigned *)pObj->pNext;
        puData0 = (unsigned *)Abc_ObjFanin0(pObj)->pNext;
        puData1 = (unsigned *)Abc_ObjFanin1(pObj)->pNext;
        // simulate
        pSop = (char *)pObj->pData;
        if ( pSop[0] == '0' && pSop[1] == '0' )
            for ( k = 0; k < pManScl->nWords; k++ )
                puData[k] = ~puData0[k] & ~puData1[k];
        else if ( pSop[0] == '0' )
            for ( k = 0; k < pManScl->nWords; k++ )
                puData[k] = ~puData0[k] & puData1[k];
        else if ( pSop[1] == '0' )
            for ( k = 0; k < pManScl->nWords; k++ )
                puData[k] = puData0[k] & ~puData1[k];
        else 
            for ( k = 0; k < pManScl->nWords; k++ )
                puData[k] = puData0[k] & puData1[k];
    }
    return puData;
}

Abc_NtkSpecialMap_rec()

Abc_Obj_t * Abc_NtkSpecialMap_rec	(	Abc_Ntk_t *	pNew,
		Abc_Obj_t *	pObj,
		Vec_Wec_t *	vSupps,
		Vec_Int_t *	vCover )

Definition at line 820 of file abcLut.c.

{
    if ( pObj->pCopy )
        return pObj->pCopy;
    if ( Abc_ObjFaninNum(pObj) == 0 )
        return NULL;
    assert( Abc_ObjFaninNum(pObj) == 3 );
    if ( pObj->fMarkA || pObj->fMarkB )
    {
        Abc_Obj_t * pFan0 = Abc_NtkSpecialMap_rec( pNew, Abc_ObjFanin(pObj, 2), vSupps, vCover );
        Abc_Obj_t * pFan1 = Abc_NtkSpecialMap_rec( pNew, Abc_ObjFanin(pObj, 1), vSupps, vCover );
        Abc_Obj_t * pFanC = Abc_NtkSpecialMap_rec( pNew, Abc_ObjFanin(pObj, 0), vSupps, vCover );
        if ( pFan0 == NULL )
            pFan0 = Abc_NodeIsConst0(Abc_ObjFanin(pObj, 2)) ? Abc_NtkCreateNodeConst0(pNew) : Abc_NtkCreateNodeConst1(pNew);
        if ( pFan1 == NULL )
            pFan1 = Abc_NodeIsConst0(Abc_ObjFanin(pObj, 1)) ? Abc_NtkCreateNodeConst0(pNew) : Abc_NtkCreateNodeConst1(pNew);
        pObj->pCopy = Abc_NtkCreateNodeMux( pNew, pFanC, pFan1, pFan0 );
        pObj->pCopy->fMarkA = pObj->fMarkA;
        pObj->pCopy->fMarkB = pObj->fMarkB;
    }
    else
    {
        Abc_Obj_t * pTemp; int i; word Truth;
        Vec_Int_t * vSupp = Vec_WecEntry( vSupps, Abc_ObjId(pObj) );
        Abc_NtkForEachObjVec( vSupp, pObj->pNtk, pTemp, i )
            Abc_NtkSpecialMap_rec( pNew, pTemp, vSupps, vCover );
        pObj->pCopy = Abc_NtkCreateNode( pNew );   
        Abc_NtkForEachObjVec( vSupp, pObj->pNtk, pTemp, i )
            Abc_ObjAddFanin( pObj->pCopy, pTemp->pCopy );
        Truth = Abc_ObjComputeTruth( pObj, vSupp );
        pObj->pCopy->pData = Abc_SopCreateFromTruthIsop( (Mem_Flex_t *)pNew->pManFunc, Vec_IntSize(vSupp), &Truth, vCover );
        assert( Abc_SopGetVarNum((char *)pObj->pCopy->pData) == Vec_IntSize(vSupp) );
    }
    return pObj->pCopy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkSpecialMapping()

Abc_Ntk_t * Abc_NtkSpecialMapping	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

Definition at line 855 of file abcLut.c.

{
    Abc_Ntk_t * pNtkNew;
    Vec_Int_t * vCover = Vec_IntAlloc( 1 << 16 );
    Vec_Wec_t * vSupps = Vec_WecStart( Abc_NtkObjNumMax(pNtk) );
    Abc_Obj_t * pObj, * pFan0, * pFan1, * pFanC; int i, Count[2] = {0};
    Abc_NtkForEachCi( pNtk, pObj, i )
        Vec_IntPush( Vec_WecEntry(vSupps, i), i );
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        Vec_Int_t * vSupp = Vec_WecEntry(vSupps, i);
        if ( Abc_ObjFaninNum(pObj) == 0 )
            continue;
        assert( Abc_ObjFaninNum(pObj) == 3 );
        pFan0 = Abc_ObjFanin( pObj, 2 );
        pFan1 = Abc_ObjFanin( pObj, 1 );
        pFanC = Abc_ObjFanin0( pObj );
        assert( Abc_ObjIsCi(pFanC) );
        if ( pFan0->fMarkA && pFan1->fMarkA )
        {
            pObj->fMarkB = 1;
            Vec_IntPush( vSupp, Abc_ObjId(pObj) );
            continue;
        }
        Vec_IntTwoMerge2( Vec_WecEntry(vSupps, Abc_ObjId(pFan0)), Vec_WecEntry(vSupps, Abc_ObjId(pFan1)), vSupp );
        assert( Vec_IntFind(vSupp, Abc_ObjId(pFanC)) == -1 );
        Vec_IntPushOrder( vSupp, Abc_ObjId(pFanC) );
        if ( Vec_IntSize(vSupp) <= 6 )
            continue;
        Vec_IntClear( vSupp );
        if ( !pFan0->fMarkA && !pFan1->fMarkA )
        {
            pObj->fMarkA = 1;
            Vec_IntPush( vSupp, Abc_ObjId(pObj) );
        }
        else
        {
            Vec_IntPushOrder( vSupp, Abc_ObjId(pFan0) );
            Vec_IntPushOrder( vSupp, Abc_ObjId(pFan1) );
            Vec_IntPushOrder( vSupp, Abc_ObjId(pFanC) );
        }
    }
 
    if ( fVerbose )
    {
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        printf( "Node %4d : ", i );
        if ( pObj->fMarkA )
            printf( " MarkA  " );
        else
            printf( "        " );
        if ( pObj->fMarkB )
            printf( " MarkB  " );
        else
            printf( "        " );
        Vec_IntPrint( Vec_WecEntry(vSupps, i) );
    }
    }
 
    Abc_NtkCleanCopy( pNtk );
    pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_SOP );
    Abc_NtkForEachCo( pNtk, pObj, i )
        if ( Abc_ObjFaninNum(Abc_ObjFanin0(pObj)) == 0 )
            Abc_ObjFanin0(pObj)->pCopy = Abc_NodeIsConst0(Abc_ObjFanin0(pObj)) ? Abc_NtkCreateNodeConst0(pNtkNew) : Abc_NtkCreateNodeConst1(pNtkNew);
        else
            Abc_NtkSpecialMap_rec( pNtkNew, Abc_ObjFanin0(pObj), vSupps, vCover );
    Abc_NtkFinalize( pNtk, pNtkNew );
    Abc_NtkCleanMarkAB( pNtk );
    Vec_WecFree( vSupps );
    Vec_IntFree( vCover );
 
    Abc_NtkForEachNode( pNtkNew, pObj, i )
    {
        Count[0] += pObj->fMarkA,
        Count[1] += pObj->fMarkB;
        pObj->fPersist = pObj->fMarkA | pObj->fMarkB;
        pObj->fMarkA = pObj->fMarkB = 0;
    }
    //printf( "Total = %3d.  Nodes = %3d. MarkA = %3d. MarkB = %3d.\n", Abc_NtkNodeNum(pNtkNew), 
    //    Abc_NtkNodeNum(pNtkNew) - Count[0] - Count[1], Count[0], Count[1] );
 
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        printf( "Abc_NtkSpecialMapping: The network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

Abc_NtkSuperChoiceLut()

int Abc_NtkSuperChoiceLut	(	Abc_Ntk_t *	pNtk,
		int	nLutSize,
		int	nCutSizeMax,
		int	fVerbose )

FUNCTION DEFINITIONS ///.

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

Synopsis [Performs superchoicing for K-LUTs.]

Description []

SideEffects []

SeeAlso []

Definition at line 81 of file abcLut.c.

{
    ProgressBar * pProgress;
    Abc_ManCut_t * pManCut;
    Abc_ManScl_t * pManScl;
    Cut_Man_t * pManCuts;
    Abc_Obj_t * pObj, * pFanin, * pObjTop;
    int i, LevelMax, nNodes;
    int nNodesTried, nNodesDec, nNodesExist, nNodesUsed;
 
    assert( Abc_NtkIsSopLogic(pNtk) );
    if ( nLutSize < 3 || nLutSize > SCL_LUT_MAX )
    {
        printf( "LUT size (%d) does not belong to the interval: 3 <= LUT size <= %d\n", nLutSize, SCL_LUT_MAX );
        return 0;
    }
    if ( nCutSizeMax <= nLutSize || nCutSizeMax > SCL_VARS_MAX )
    {
        printf( "Cut size (%d) does not belong to the interval: LUT size (%d) < Cut size <= %d\n", nCutSizeMax, nLutSize, SCL_VARS_MAX );
        return 0;
    }
 
    assert( nLutSize <= SCL_LUT_MAX );
    assert( nCutSizeMax <= SCL_VARS_MAX );
    nNodesTried = nNodesDec = nNodesExist = nNodesUsed = 0;
 
    // set the delays of the CIs
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->Level = 0;
 
//Abc_NtkLevel( pNtk );
 
    // start the managers
    pManScl = Abc_ManSclStart( nLutSize, nCutSizeMax, 1000 );
    pManCuts = Abc_NtkStartCutManForScl( pNtk, nLutSize );
    pManCut = Abc_NtkManCutStart( nCutSizeMax, 100000, 100000, 100000 );
    s_pLeaves = Abc_NtkManCutReadCutSmall( pManCut );
    pManScl->vVolume = Abc_NtkManCutReadVisited( pManCut );
 
    // process each internal node (assuming topological order of nodes!!!)
    nNodes = Abc_NtkObjNumMax(pNtk);
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    Abc_NtkForEachObj( pNtk, pObj, i )
    {
//        if ( i != nNodes-1 )
//            continue;
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        if ( i >= nNodes )
            break;
        if ( Abc_ObjFaninNum(pObj) != 2 )
            continue;
        nNodesTried++;
 
        // map this node using regular cuts
//        pObj->Level = 0;
        Abc_NodeLutMap( pManCuts, pObj );
        // compute the cut
        pManScl->vLeaves = Abc_NodeFindCut( pManCut, pObj, 0 );
        if ( Vec_PtrSize(pManScl->vLeaves) <= nLutSize )
            continue;
        // get the volume of the cut
        if ( Vec_PtrSize(pManScl->vVolume) > SCL_NODE_MAX )
            continue;
        nNodesDec++;
 
        // decompose the cut
        pObjTop = Abc_NodeSuperChoiceLut( pManScl, pObj );
        if ( pObjTop == NULL )
            continue;
        nNodesExist++;
 
        // if there is no delay improvement, skip; otherwise, update level
        if ( pObjTop->Level >= pObj->Level )
        {
            Abc_NtkDeleteObj_rec( pObjTop, 1 );
            continue;
        }
        pObj->Level = pObjTop->Level;
        nNodesUsed++;
    }
    Extra_ProgressBarStop( pProgress );
 
    // delete the managers
    Abc_ManSclStop( pManScl );
    Abc_NtkManCutStop( pManCut );
    Cut_ManStop( pManCuts );
 
    // get the largest arrival time
    LevelMax = 0;
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        pFanin = Abc_ObjFanin0( pObj );
        // skip inv/buf
        if ( Abc_ObjFaninNum(pFanin) == 1 )
            pFanin = Abc_ObjFanin0( pFanin );
        // get the new level
        LevelMax = Abc_MaxInt( LevelMax, (int)pFanin->Level );
    }
 
    if ( fVerbose )
    printf( "Try = %d. Dec = %d. Exist = %d. Use = %d. SUPER = %d levels of %d-LUTs.\n", 
        nNodesTried, nNodesDec, nNodesExist, nNodesUsed, LevelMax, nLutSize );
//    if ( fVerbose )
//    printf( "The network is superchoiced for %d levels of %d-LUTs.\n", LevelMax, nLutSize );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->pNext = NULL;
 
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkSuperChoiceLut: The network check has failed.\n" );
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Abc_ObjComputeTruth()

word Abc_ObjComputeTruth	(	Abc_Obj_t *	pObj,
		Vec_Int_t *	vSupp )

Definition at line 805 of file abcLut.c.

{
    int Index; word t0, t1, tc;
    assert( Vec_IntSize(vSupp) <= 6 );
    if ( (Index = Vec_IntFind(vSupp, Abc_ObjId(pObj))) >= 0 )
        return s__Truths6[Index];
    assert( Abc_ObjIsNode(pObj) );
    if ( Abc_ObjFaninNum(pObj) == 0 )
        return Abc_NodeIsConst0(pObj) ? (word)0 : ~(word)0;
    assert( Abc_ObjFaninNum(pObj) == 3 );
    t0 = Abc_ObjComputeTruth( Abc_ObjFanin(pObj, 2), vSupp );
    t1 = Abc_ObjComputeTruth( Abc_ObjFanin(pObj, 1), vSupp );
    tc = Abc_ObjComputeTruth( Abc_ObjFanin(pObj, 0), vSupp );
    return (tc & t1) | (~tc & t0);
}

Here is the call graph for this function:

Here is the caller graph for this function: