bdc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Bdc_Par_t_

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Bdc_Fun_t_	Bdc_Fun_t
	INCLUDES ///.
typedef struct Bdc_Man_t_	Bdc_Man_t
typedef struct Bdc_Par_t_	Bdc_Par_t

Functions
Bdc_Man_t *	Bdc_ManAlloc (Bdc_Par_t *pPars)
	MACRO DEFINITIONS ///.
void	Bdc_ManFree (Bdc_Man_t *p)
void	Bdc_ManDecPrint (Bdc_Man_t *p)
int	Bdc_ManDecompose (Bdc_Man_t *p, unsigned *puFunc, unsigned *puCare, int nVars, Vec_Ptr_t *vDivs, int nNodesMax)
Bdc_Fun_t *	Bdc_ManFunc (Bdc_Man_t *p, int i)
	DECLARATIONS ///.
Bdc_Fun_t *	Bdc_ManRoot (Bdc_Man_t *p)
int	Bdc_ManNodeNum (Bdc_Man_t *p)
int	Bdc_ManAndNum (Bdc_Man_t *p)
Bdc_Fun_t *	Bdc_FuncFanin0 (Bdc_Fun_t *p)
Bdc_Fun_t *	Bdc_FuncFanin1 (Bdc_Fun_t *p)
void *	Bdc_FuncCopy (Bdc_Fun_t *p)
int	Bdc_FuncCopyInt (Bdc_Fun_t *p)
void	Bdc_FuncSetCopy (Bdc_Fun_t *p, void *pCopy)
void	Bdc_FuncSetCopyInt (Bdc_Fun_t *p, int iCopy)
int	Bdc_ManBidecNodeNum (word *pFunc, word *pCare, int nVars, int fVerbose)
Vec_Int_t *	Bdc_ManBidecResub (word *pFunc, word *pCare, int nVars)

Typedef Documentation

Bdc_Fun_t

typedef typedefABC_NAMESPACE_HEADER_START struct Bdc_Fun_t_ Bdc_Fun_t

INCLUDES ///.

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

FileName [bdc.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Truth-table-based bi-decomposition engine.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - January 30, 2007.]

Revision [

Id

bdc.h,v 1.00 2007/01/30 00:00:00 alanmi Exp

] PARAMETERS /// BASIC TYPES ///

Definition at line 42 of file bdc.h.

Bdc_Man_t

typedef struct Bdc_Man_t_ Bdc_Man_t

Definition at line 43 of file bdc.h.

Bdc_Par_t

typedef struct Bdc_Par_t_ Bdc_Par_t

Definition at line 44 of file bdc.h.

Function Documentation

Bdc_FuncCopy()

void * Bdc_FuncCopy ( Bdc_Fun_t * p )

extern

Definition at line 52 of file bdcCore.c.

{ return p->pCopy;            }

Bdc_FuncCopyInt()

int Bdc_FuncCopyInt ( Bdc_Fun_t * p )

extern

Definition at line 53 of file bdcCore.c.

{ return p->iCopy;            }

Bdc_FuncFanin0()

Bdc_Fun_t * Bdc_FuncFanin0 ( Bdc_Fun_t * p )

extern

Definition at line 50 of file bdcCore.c.

{ return p->pFan0;            }

Here is the caller graph for this function:

Bdc_FuncFanin1()

Bdc_Fun_t * Bdc_FuncFanin1 ( Bdc_Fun_t * p )

extern

Definition at line 51 of file bdcCore.c.

{ return p->pFan1;            }

Here is the caller graph for this function:

Bdc_FuncSetCopy()

void Bdc_FuncSetCopy ( Bdc_Fun_t * p, void * pCopy )

extern

Definition at line 54 of file bdcCore.c.

{ p->pCopy = pCopy;           }

Here is the caller graph for this function:

Bdc_FuncSetCopyInt()

void Bdc_FuncSetCopyInt ( Bdc_Fun_t * p, int iCopy )

extern

Definition at line 55 of file bdcCore.c.

{ p->iCopy = iCopy;           }

Here is the caller graph for this function:

Bdc_ManAlloc()

Bdc_Man_t * Bdc_ManAlloc ( Bdc_Par_t * pPars )

extern

MACRO DEFINITIONS ///.

FUNCTION DECLARATIONS ///

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

Synopsis [Allocate resynthesis manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 68 of file bdcCore.c.

{
    Bdc_Man_t * p;
    p = ABC_ALLOC( Bdc_Man_t, 1 );
    memset( p, 0, sizeof(Bdc_Man_t) );
    assert( pPars->nVarsMax > 1 && pPars->nVarsMax < 16 );
    p->pPars = pPars;
    p->nWords = Kit_TruthWordNum( pPars->nVarsMax );
    p->nDivsLimit = 200;
    // internal nodes
    p->nNodesAlloc = 512;
    p->pNodes = ABC_ALLOC( Bdc_Fun_t, p->nNodesAlloc );
    // memory
    p->vMemory = Vec_IntStart( 8 * p->nWords * p->nNodesAlloc );
    Vec_IntClear(p->vMemory);
    // set up hash table
    p->nTableSize = (1 << p->pPars->nVarsMax);
    p->pTable = ABC_ALLOC( Bdc_Fun_t *, p->nTableSize );
    memset( p->pTable, 0, sizeof(Bdc_Fun_t *) * p->nTableSize );
    p->vSpots = Vec_IntAlloc( 256 );
    // truth tables
    p->vTruths = Vec_PtrAllocTruthTables( p->pPars->nVarsMax );
    p->puTemp1 = ABC_ALLOC( unsigned, 4 * p->nWords );
    p->puTemp2 = p->puTemp1 + p->nWords;
    p->puTemp3 = p->puTemp2 + p->nWords;
    p->puTemp4 = p->puTemp3 + p->nWords;
    // start the internal ISFs
    p->pIsfOL = &p->IsfOL;  Bdc_IsfStart( p, p->pIsfOL );
    p->pIsfOR = &p->IsfOR;  Bdc_IsfStart( p, p->pIsfOR );
    p->pIsfAL = &p->IsfAL;  Bdc_IsfStart( p, p->pIsfAL );
    p->pIsfAR = &p->IsfAR;  Bdc_IsfStart( p, p->pIsfAR );   
    return p; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bdc_ManAndNum()

int Bdc_ManAndNum ( Bdc_Man_t * p )

extern

Definition at line 49 of file bdcCore.c.

{ return p->nNodes-p->nVars-1;}

Here is the caller graph for this function:

Bdc_ManBidecNodeNum()

int Bdc_ManBidecNodeNum ( word * pFunc, word * pCare, int nVars, int fVerbose )

extern

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

Synopsis [Performs decomposition of one function.]

Description []

SideEffects []

SeeAlso []

Definition at line 378 of file bdcCore.c.

{
    int nNodes;
    Bdc_Man_t * pManDec;
    Bdc_Par_t Pars = {0}, * pPars = &Pars;
    pPars->nVarsMax = nVars;
    pManDec = Bdc_ManAlloc( pPars );
    Bdc_ManDecompose( pManDec, (unsigned *)pFunc, (unsigned *)pCare, nVars, NULL, 1000 );
    nNodes = Bdc_ManAndNum( pManDec );
    if ( fVerbose )
        Bdc_ManDecPrint( pManDec );
    Bdc_ManFree( pManDec );
    return nNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bdc_ManBidecResub()

Vec_Int_t * Bdc_ManBidecResub ( word * pFunc, word * pCare, int nVars )

extern

Definition at line 426 of file bdcCore.c.

{
    Vec_Int_t * vRes = NULL;
    int nNodes;
    Bdc_Man_t * pManDec; 
    Bdc_Par_t Pars = {0}, * pPars = &Pars;
    pPars->nVarsMax = nVars;
    pManDec = Bdc_ManAlloc( pPars );
    Bdc_ManDecompose( pManDec, (unsigned *)pFunc, (unsigned *)pCare, nVars, NULL, 1000 );
    if ( pManDec->pRoot != NULL )
    {
        //Bdc_ManDecPrint( pManDec );
        nNodes = Bdc_ManAndNum( pManDec );
        vRes = Vec_IntAlloc( 2*nNodes + 1 );
        Bdc_ManBidecResubInt( pManDec, vRes );
        assert( Vec_IntSize(vRes) == 2*nNodes + 1 );
    }
    Bdc_ManFree( pManDec );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bdc_ManDecompose()

int Bdc_ManDecompose ( Bdc_Man_t * p, unsigned * puFunc, unsigned * puCare, int nVars, Vec_Ptr_t * vDivs, int nNodesMax )

extern

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

Synopsis [Performs decomposition of one function.]

Description []

SideEffects []

SeeAlso []

Definition at line 291 of file bdcCore.c.

{
    Bdc_Isf_t Isf, * pIsf = &Isf;
    abctime clk = Abc_Clock();
    assert( nVars <= p->pPars->nVarsMax );
    // set current manager parameters
    p->nVars = nVars;
    p->nWords = Kit_TruthWordNum( nVars );
    p->nNodesMax = nNodesMax;
    Bdc_ManPrepare( p, vDivs );
    if ( puCare && Kit_TruthIsConst0( puCare, nVars ) )
    {
        p->pRoot = Bdc_Not(p->pNodes);
        return 0;
    }
    // copy the function
    Bdc_IsfStart( p, pIsf );
    if ( puCare )
    {
        Kit_TruthAnd( pIsf->puOn, puCare, puFunc, p->nVars );
        Kit_TruthSharp( pIsf->puOff, puCare, puFunc, p->nVars );
    }
    else
    {
        Kit_TruthCopy( pIsf->puOn, puFunc, p->nVars );
        Kit_TruthNot( pIsf->puOff, puFunc, p->nVars );
    }
    Bdc_SuppMinimize( p, pIsf );
    // call decomposition
    p->pRoot = Bdc_ManDecompose_rec( p, pIsf );
    p->timeTotal += Abc_Clock() - clk;
    p->numCalls++;
    p->numNodes += p->nNodesNew;
    if ( p->pRoot == NULL )
        return -1;
    if ( !Bdc_ManNodeVerify( p, pIsf, p->pRoot ) )
        printf( "Bdc_ManDecompose(): Internal verification failed.\n" );
//    assert( Bdc_ManNodeVerify( p, pIsf, p->pRoot ) );
    return p->nNodesNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bdc_ManDecPrint()

void Bdc_ManDecPrint ( Bdc_Man_t * p )

extern

Definition at line 260 of file bdcCore.c.

{
    Bdc_Fun_t * pRoot = Bdc_Regular(p->pRoot);
 
    printf( "F = " );
    if ( pRoot->Type == BDC_TYPE_CONST1 ) // constant 0
        printf( "Constant %d", !Bdc_IsComplement(p->pRoot) );
    else if ( pRoot->Type == BDC_TYPE_PI ) // literal
        printf( "%s%d", Bdc_IsComplement(p->pRoot) ? "!" : "", Bdc_FunId(p,pRoot)-1 );
    else
    {
        if ( Bdc_IsComplement(p->pRoot) )
            printf( "!(" );
        Bdc_ManDecPrint_rec( p, pRoot );
        if ( Bdc_IsComplement(p->pRoot) )
            printf( ")" );
    }
    printf( "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bdc_ManFree()

void Bdc_ManFree ( Bdc_Man_t * p )

extern

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

Synopsis [Deallocate resynthesis manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 113 of file bdcCore.c.

{
    if ( p->pPars->fVerbose )
    {
        printf( "Bi-decomposition stats: Calls = %d.  Nodes = %d. Reuse = %d.\n", 
            p->numCalls, p->numNodes, p->numReuse );
        printf( "ANDs = %d.  ORs = %d.  Weak = %d.  Muxes = %d.  Memory = %.2f K\n", 
            p->numAnds, p->numOrs, p->numWeaks, p->numMuxes, 4.0 * Vec_IntSize(p->vMemory) / (1<<10) );
        ABC_PRT( "Cache", p->timeCache );
        ABC_PRT( "Check", p->timeCheck );
        ABC_PRT( "Muxes", p->timeMuxes );
        ABC_PRT( "Supps", p->timeSupps );
        ABC_PRT( "TOTAL", p->timeTotal );
    }
    Vec_IntFree( p->vMemory );
    Vec_IntFree( p->vSpots );
    Vec_PtrFree( p->vTruths );
    ABC_FREE( p->puTemp1 );
    ABC_FREE( p->pNodes );
    ABC_FREE( p->pTable );
    ABC_FREE( p );
}

Here is the caller graph for this function:

Bdc_ManFunc()

Bdc_Fun_t * Bdc_ManFunc ( Bdc_Man_t * p, int i )

extern

DECLARATIONS ///.

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

FileName [bdcCore.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Truth-table-based bi-decomposition engine.]

Synopsis [The gateway to bi-decomposition.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - January 30, 2007.]

Revision [

Id

bdcCore.c,v 1.00 2007/01/30 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Accessing contents of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 46 of file bdcCore.c.

{ return Bdc_FunWithId(p, i); }

Here is the caller graph for this function:

Bdc_ManNodeNum()

int Bdc_ManNodeNum ( Bdc_Man_t * p )

extern

Definition at line 48 of file bdcCore.c.

{ return p->nNodes;           }

Here is the caller graph for this function:

Bdc_ManRoot()

Bdc_Fun_t * Bdc_ManRoot ( Bdc_Man_t * p )

extern

Definition at line 47 of file bdcCore.c.

{ return p->pRoot;            }

Here is the caller graph for this function: