acecInt.h File Reference

#include "aig/gia/gia.h"
#include "acec.h"

Include dependency graph for acecInt.h:

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

Go to the source code of this file.

Classes
struct	Acec_Box_t_

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Acec_Box_t_	Acec_Box_t
	INCLUDES ///.

Functions
Vec_Int_t *	Gia_PolynCoreOrder (Gia_Man_t *pGia, Vec_Int_t *vAdds, Vec_Int_t *vAddCos, Vec_Int_t **pvIns, Vec_Int_t **pvOuts)
	ITERATORS ///.
Vec_Wec_t *	Gia_PolynCoreOrderArray (Gia_Man_t *pGia, Vec_Int_t *vAdds, Vec_Int_t *vRootBoxes)
Vec_Int_t *	Acec_MultDetectInputs (Gia_Man_t *p, Vec_Wec_t *vLeafLits, Vec_Wec_t *vRootLits)
Vec_Bit_t *	Acec_BoothFindPPG (Gia_Man_t *p)
Vec_Bit_t *	Acec_MultMarkPPs (Gia_Man_t *p)
void	Acec_InsertFadd (Gia_Man_t *pNew, int In[3], int Out[2])
Gia_Man_t *	Acec_InsertBox (Acec_Box_t *pBox, int fAll)
void	Acec_PrintAdders (Vec_Wec_t *vBoxes, Vec_Int_t *vAdds)
void	Acec_TreePrintBox (Acec_Box_t *pBox, Vec_Int_t *vAdds)
Acec_Box_t *	Acec_DeriveBox (Gia_Man_t *p, Vec_Bit_t *vIgnore, int fFilterIn, int fFilterOut, int fVerbose)
void	Acec_BoxFreeP (Acec_Box_t **ppBox)
void	Gia_PolynAnalyzeXors (Gia_Man_t *pGia, int fVerbose)
Vec_Int_t *	Gia_PolynCollectLastXor (Gia_Man_t *pGia, int fVerbose)
Acec_Box_t *	Acec_ProduceBox (Gia_Man_t *p, int fVerbose)

Typedef Documentation

Acec_Box_t

typedef typedefABC_NAMESPACE_HEADER_START struct Acec_Box_t_ Acec_Box_t

INCLUDES ///.

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

FileName [acecInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [CEC for arithmetic circuits.]

Synopsis [Internal declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

acecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

] PARAMETERS ///

Definition at line 40 of file acecInt.h.

Function Documentation

Acec_BoothFindPPG()

Vec_Bit_t * Acec_BoothFindPPG ( Gia_Man_t * p )

extern

Definition at line 656 of file acecMult.c.

{
    Vec_Bit_t * vIgnore = Vec_BitStart( Gia_ManObjNum(p) );
    Vec_Int_t * vMap = Acec_MultFindPPs( p );
    int i, Entry;
    Vec_IntForEachEntry( vMap, Entry, i )
        Vec_BitWriteEntry( vIgnore, Entry, 1 );
    Vec_IntFree( vMap );
    return vIgnore;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_BoxFreeP()

void Acec_BoxFreeP ( Acec_Box_t ** ppBox )

extern

Definition at line 54 of file acecTree.c.

{
    if ( *ppBox )
        Acec_BoxFree( *ppBox );
    *ppBox = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_DeriveBox()

Acec_Box_t * Acec_DeriveBox ( Gia_Man_t * p, Vec_Bit_t * vIgnore, int fFilterIn, int fFilterOut, int fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 754 of file acecTree.c.

{
    Acec_Box_t * pBox = NULL;
    Vec_Int_t * vAdds = Ree_ManComputeCuts( p, NULL, fVerbose );
    Vec_Wec_t * vTrees = Acec_TreeFindTrees( p, vAdds, vIgnore, fFilterIn, fFilterOut );
    if ( vTrees && Vec_WecSize(vTrees) > 0 )
    {
        pBox = Acec_CreateBox( p, vAdds, Vec_WecEntry(vTrees, 0) );
        Acec_VerifyBoxLeaves( pBox, vIgnore );
    }
    if ( pBox )//&& fVerbose )
        printf( "Processing tree %d:  Ranks = %d.  Adders = %d.  Leaves = %d.  Roots = %d.\n", 
            0, Vec_WecSize(pBox->vAdds), Vec_WecSizeSize(pBox->vAdds), 
            Vec_WecSizeSize(pBox->vLeafLits), Vec_WecSizeSize(pBox->vRootLits)  );
    if ( pBox && fVerbose )
        Acec_TreePrintBox( pBox, vAdds );
    //Acec_PrintAdders( pBox0->vAdds, vAdds );
    //Acec_MultDetectInputs( p, pBox->vLeafLits, pBox->vRootLits );
    Vec_WecFreeP( &vTrees );
    Vec_IntFree( vAdds );
    return pBox;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_InsertBox()

Gia_Man_t * Acec_InsertBox ( Acec_Box_t * pBox, int fAll )

extern

Definition at line 156 of file acecNorm.c.

{
    Gia_Man_t * p = pBox->pGia;
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    Vec_Int_t * vRootRanks, * vLevel, * vTemp;
    int i, k, iLit, iLitNew;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManFillValue(p);
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    // implement tree
    if ( fAll )
        vRootRanks = Acec_BuildTree( pNew, p, pBox->vLeafLits, NULL );
    else
    {
        assert( pBox->vShared != NULL );
        assert( pBox->vUnique != NULL );
        vRootRanks = Acec_BuildTree( pNew, p, pBox->vShared, NULL );
        vRootRanks = Acec_BuildTree( pNew, p, pBox->vUnique, vTemp = vRootRanks );
        Vec_IntFree( vTemp );
    }
    // update polarity of literals
    Vec_WecForEachLevel( pBox->vRootLits, vLevel, i )
        Vec_IntForEachEntry( vLevel, iLit, k )
        {
            pObj = Gia_ManObj( p, Abc_Lit2Var(iLit) );
            iLitNew = k ? 0 : Vec_IntEntry( vRootRanks, i );
            pObj->Value = Abc_LitNotCond( iLitNew, Abc_LitIsCompl(iLit) );
        }
    Vec_IntFree( vRootRanks );
    // construct the outputs
    Gia_ManForEachCo( p, pObj, i )
        Acec_InsertBox_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_InsertFadd()

void Acec_InsertFadd ( Gia_Man_t * pNew, int In[3], int Out[2] )

extern

Definition at line 53 of file acecNorm.c.

{
    int In2[2], Out1[2], Out2[2];
    Acec_InsertHadd( pNew, In, Out1 );
    In2[0] = Out1[0];
    In2[1] = In[2];
    Acec_InsertHadd( pNew, In2, Out2 );
    Out[0] = Out2[0];
    Out[1] = Gia_ManAppendOr2( pNew, Out1[1], Out2[1] );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_MultDetectInputs()

Vec_Int_t * Acec_MultDetectInputs ( Gia_Man_t * p, Vec_Wec_t * vLeafLits, Vec_Wec_t * vRootLits )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 431 of file acecMult.c.

{
    Vec_Int_t * vInputs = Vec_IntAlloc( 100 );
    Vec_Int_t * vSupp = Vec_IntAlloc( 100 );
    Vec_Wrd_t * vTemp = Vec_WrdStart( Gia_ManObjNum(p) );
    Vec_Int_t * vRanks  = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vCounts = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vLevel;
    int i, k, iLit, iObj, j, Entry;
 
    ABC_FREE( p->pRefs );
    Gia_ManCreateRefs( p );
    Gia_ManForEachCiId( p, iObj, i )
        printf( "%d=%d ", iObj, Gia_ObjRefNumId(p, iObj) );
    printf( "\n" );
    Gia_ManForEachAndId( p, iObj )
        if ( Gia_ObjRefNumId(p, iObj) >= 4 )
            printf( "%d=%d ", iObj, Gia_ObjRefNumId(p, iObj) );
    printf( "\n" );
 
    Vec_WecForEachLevel( vLeafLits, vLevel, i )
        Vec_IntForEachEntry( vLevel, iLit, k )
        {
            word Truth = Gia_ObjComputeTruth6Cis( p, iLit, vSupp, vTemp );
            if ( Vec_IntSize(vSupp) >= 0 )
            {
                printf( "Leaf = %4d : ", Abc_Lit2Var(iLit) );
                printf( "Rank = %2d  ", i );
                printf( "Supp = %2d  ", Vec_IntSize(vSupp) );
                Extra_PrintHex( stdout, (unsigned*)&Truth, Vec_IntSize(vSupp) );
                if ( Vec_IntSize(vSupp) == 4 ) printf( "    " );
                if ( Vec_IntSize(vSupp) == 3 ) printf( "      " );
                if ( Vec_IntSize(vSupp) <= 2 ) printf( "       " );
                printf( "  " );
                Vec_IntPrint( vSupp );
                /*
                if ( Truth == 0xF335ACC0F335ACC0 )
                {
                    int iObj = Abc_Lit2Var(iLit);
                    Gia_Man_t * pGia0 = Gia_ManDupAndCones( p, &iObj, 1, 1 );
                    Gia_ManShow( pGia0, NULL, 0, 0, 0 );
                    Gia_ManStop( pGia0 );
                }
                */
            }
            // support rank counts
            Vec_IntForEachEntry( vSupp, Entry, j )
            {
                Vec_IntAddToEntry( vRanks, Entry, i );
                Vec_IntAddToEntry( vCounts, Entry, 1 );
            }
            if ( k == Vec_IntSize(vLevel)-1 )
                printf( "\n" );
        }
 
    Vec_IntForEachEntry( vCounts, Entry, j )
        if ( Entry )
            printf( "%d=%d(%.2f) ", j, Entry, 1.0*Vec_IntEntry(vRanks, j)/Entry );
    printf( "\n" );
 
    Vec_IntFree( vSupp );
    Vec_WrdFree( vTemp );
    Vec_IntFree( vRanks );
    Vec_IntFree( vCounts );
    return vInputs;
}

Here is the call graph for this function:

Acec_MultMarkPPs()

Vec_Bit_t * Acec_MultMarkPPs ( Gia_Man_t * p )

extern

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

Synopsis [Mark nodes whose function is exactly that of a Booth PP.]

Description []

SideEffects []

SeeAlso []

Definition at line 509 of file acecMult.c.

{
    word Saved[32] = {
        ABC_CONST(0xF335ACC0F335ACC0),
        ABC_CONST(0x35C035C035C035C0),
        ABC_CONST(0xD728D728D728D728),
        ABC_CONST(0xFD80FD80FD80FD80),
        ABC_CONST(0xACC0ACC0ACC0ACC0),
        ABC_CONST(0x7878787878787878),
        ABC_CONST(0x2828282828282828),
        ABC_CONST(0xD0D0D0D0D0D0D0D0),
        ABC_CONST(0x8080808080808080),
        ABC_CONST(0x8888888888888888),
        ABC_CONST(0xAAAAAAAAAAAAAAAA),
        ABC_CONST(0x5555555555555555),
 
        ABC_CONST(0xD5A8D5A8D5A8D5A8),
        ABC_CONST(0x2A572A572A572A57),
        ABC_CONST(0xF3C0F3C0F3C0F3C0),
        ABC_CONST(0x5858585858585858),
        ABC_CONST(0xA7A7A7A7A7A7A7A7),
        ABC_CONST(0x2727272727272727),
        ABC_CONST(0xD8D8D8D8D8D8D8D8)
    };
 
    Vec_Bit_t * vRes = Vec_BitStart( Gia_ManObjNum(p) );
    Vec_Wrd_t * vTemp = Vec_WrdStart( Gia_ManObjNum(p) );
    Vec_Int_t * vSupp = Vec_IntAlloc( 100 );
    int i, iObj, nProds = 0;
    Gia_ManCleanMark0(p);
    Gia_ManForEachAndId( p, iObj )
    {
        word Truth = Gia_ObjComputeTruth6Cis( p, Abc_Var2Lit(iObj, 0), vSupp, vTemp );
        if ( Vec_IntSize(vSupp) > 6  )
            continue;
        vSupp->nSize = Abc_Tt6MinBase( &Truth, vSupp->pArray, vSupp->nSize );
        if ( Vec_IntSize(vSupp) > 5  )
            continue;
        for ( i = 0; i < 32 && Saved[i]; i++ )
        {
            if ( Truth == Saved[i] || Truth == ~Saved[i] )
            {
                Vec_BitWriteEntry( vRes, iObj, 1 );
                nProds++;
                break;
            }
        }
    }
    Gia_ManCleanMark0(p);
    printf( "Collected %d pps.\n", nProds );
    Vec_IntFree( vSupp );
    Vec_WrdFree( vTemp );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_PrintAdders()

void Acec_PrintAdders ( Vec_Wec_t * vBoxes, Vec_Int_t * vAdds )

extern

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

Synopsis [Derives one adder tree.]

Description []

SideEffects []

SeeAlso [] `

Definition at line 570 of file acecTree.c.

{
    Vec_Int_t * vLevel;
    int i, k, iBox;
    Vec_WecForEachLevel( vBoxes, vLevel, i )
    {
        printf( " %4d : %2d  {", i, Vec_IntSize(vLevel) );
        Vec_IntForEachEntry( vLevel, iBox, k )
        {
            printf( " %s%d=(%d,%d)", Vec_IntEntry(vAdds, 6*iBox+2) == 0 ? "*":"", iBox, 
                                     Vec_IntEntry(vAdds, 6*iBox+3), Vec_IntEntry(vAdds, 6*iBox+4) );
            //printf( "(%d,%d,%d)", Vec_IntEntry(vAdds, 6*iBox+0), Vec_IntEntry(vAdds, 6*iBox+1), Vec_IntEntry(vAdds, 6*iBox+2) );
        }
        printf( " }\n" );
    }
}

Here is the caller graph for this function:

Acec_ProduceBox()

Acec_Box_t * Acec_ProduceBox ( Gia_Man_t * p, int fVerbose )

extern

Definition at line 375 of file acecXor.c.

{
    extern void Acec_TreeVerifyConnections( Gia_Man_t * p, Vec_Int_t * vAdds, Vec_Wec_t * vBoxes );
 
    abctime clk = Abc_Clock();
    Acec_Box_t * pBox = NULL;
    Vec_Int_t * vXors, * vAdds = Ree_ManComputeCuts( p, &vXors, 0 );
    Vec_Int_t * vTemp, * vXorRoots = Acec_FindXorRoots( p, vXors ); 
    Vec_Int_t * vRanks = Acec_RankTrees( p, vXors, vXorRoots ); 
    Vec_Wec_t * vXorLeaves, * vAddBoxes = NULL; 
 
    Gia_ManLevelNum(p);
 
    //Acec_CheckXors( p, vXors );
 
    //Ree_ManPrintAdders( vAdds, 1 );
    if ( fVerbose )
        printf( "Detected %d full-adders and %d half-adders.  Found %d XOR-cuts.  ", Ree_ManCountFadds(vAdds), Vec_IntSize(vAdds)/6-Ree_ManCountFadds(vAdds), Vec_IntSize(vXors)/4 );
    if ( fVerbose )
        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
 
    vXorRoots = Acec_OrderTreeRoots( p, vAdds, vTemp = vXorRoots, vRanks );
    Vec_IntFree( vTemp );
    Vec_IntFree( vRanks );
 
    vRanks = Acec_RankTrees( p, vXors, vXorRoots ); 
    vXorLeaves = Acec_FindXorLeaves( p, vXors, vAdds, vXorRoots, vRanks, &vAddBoxes ); 
    Vec_IntFree( vRanks );
 
    //printf( "XOR roots after reordering: \n" );
    //Vec_IntPrint( vXorRoots );
    //printf( "XOR leaves: \n" );
    //Vec_WecPrint( vXorLeaves, 0 );
    //printf( "Adder boxes: \n" );
    //Vec_WecPrint( vAddBoxes, 0 );
 
    Acec_TreeVerifyConnections( p, vAdds, vAddBoxes );
 
    pBox = Acec_FindBox( p, vAdds, vAddBoxes, vXorLeaves, vXorRoots );
    //Vec_WecFree( vAddBoxes );
 
    if ( fVerbose )
        Acec_TreePrintBox( pBox, vAdds );
 
    Vec_IntFree( vXorRoots );
    Vec_WecFree( vXorLeaves );
 
    Vec_IntFree( vXors );
    Vec_IntFree( vAdds );
 
    return pBox;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Acec_TreePrintBox()

void Acec_TreePrintBox ( Acec_Box_t * pBox, Vec_Int_t * vAdds )

extern

Definition at line 586 of file acecTree.c.

{
    printf( "Adders:\n" );
    Acec_PrintAdders( pBox->vAdds, vAdds );
    printf( "Inputs:\n" );
    Vec_WecPrintLits( pBox->vLeafLits );
    printf( "Outputs:\n" );
    Vec_WecPrintLits( pBox->vRootLits );
//    printf( "Node %d has level %d.\n", 3715, Gia_ObjLevelId(pBox->pGia, 3715) );
//    printf( "Node %d has level %d.\n", 167, Gia_ObjLevelId(pBox->pGia, 167) );
//    printf( "Node %d has level %d.\n", 278, Gia_ObjLevelId(pBox->pGia, 278) );
//    printf( "Node %d has level %d.\n", 597, Gia_ObjLevelId(pBox->pGia, 597) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_PolynAnalyzeXors()

void Gia_PolynAnalyzeXors ( Gia_Man_t * pGia, int fVerbose )

extern

Definition at line 69 of file acecUtil.c.

{
    int i, iDriver, Count = 0;
    Vec_Int_t * vXors = Vec_IntAlloc( 100 );
    if ( pGia->pMuxes == NULL )
    {
        printf( "AIG does not have XORs extracted.\n" );
        return;
    }
    assert( pGia->pMuxes );
    Gia_ManForEachCoDriverId( pGia, iDriver, i )
    {
        Vec_IntClear( vXors );
        Gia_ManIncrementTravId( pGia );
        Gia_PolynCollectXors_rec( pGia, iDriver, vXors );
        //printf( "%3d : ", i );
        //Vec_IntPrint( vXors );
        printf( "%d=%d  ", i, Vec_IntSize(vXors) );
        Count += Vec_IntSize(vXors);
    }
    printf( "Total = %d.\n", Count );
    Vec_IntFree( vXors );
}

Here is the call graph for this function:

Gia_PolynCollectLastXor()

Vec_Int_t * Gia_PolynCollectLastXor ( Gia_Man_t * pGia, int fVerbose )

extern

Definition at line 57 of file acecUtil.c.

{
    Vec_Int_t * vXors = Vec_IntAlloc( 100 );
    Gia_Obj_t * pObj = Gia_ManCo( pGia, Gia_ManCoNum(pGia)-1 );
    ABC_FREE( pGia->pRefs );
    Gia_ManCreateRefs( pGia );
    Gia_ManIncrementTravId( pGia );
    Gia_PolynCollectXors_rec( pGia, Gia_ObjFaninId0p(pGia, pObj), vXors );
    Vec_IntReverseOrder( vXors );
    ABC_FREE( pGia->pRefs );
    return vXors;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_PolynCoreOrder()

Vec_Int_t * Gia_PolynCoreOrder ( Gia_Man_t * pGia, Vec_Int_t * vAdds, Vec_Int_t * vAddCos, Vec_Int_t ** pvIns, Vec_Int_t ** pvOuts )

extern

ITERATORS ///.

FUNCTION DECLARATIONS ///

Definition at line 163 of file acecCo.c.

{
    Vec_Int_t * vOrder;
    Vec_Wec_t * vMap = Gia_PolynComputeMap( vAdds, Gia_ManObjNum(pGia) );
    Vec_Int_t * vRoots = Vec_IntAlloc( Gia_ManCoNum(pGia) );
    int i, Driver;
    // collect roots
    Gia_ManForEachCoDriverId( pGia, Driver, i )
        Vec_IntPush( vRoots, Driver );
    // collect additional outputs
    if ( vAddCos )
        Vec_IntForEachEntry( vAddCos, Driver, i )
            Vec_IntPush( vRoots, Driver );
    // remember roots
    if ( pvOuts )
        *pvOuts = Vec_IntDup( vRoots );
    // create order
    vOrder = Gia_PolynCoreOrder_int( pGia, vAdds, vMap, vRoots, pvIns );
    Vec_IntFree( vRoots );
    Vec_WecFree( vMap );
    printf( "Collected %d boxes.\n", Vec_IntSize(vOrder) );
    return vOrder;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_PolynCoreOrderArray()

Vec_Wec_t * Gia_PolynCoreOrderArray ( Gia_Man_t * pGia, Vec_Int_t * vAdds, Vec_Int_t * vRootBoxes )

extern

Definition at line 222 of file acecCo.c.

{
    extern Vec_Bit_t * Acec_ManPoolGetPointed( Gia_Man_t * p, Vec_Int_t * vAdds );
    Vec_Bit_t * vMarks = Acec_ManPoolGetPointed( pGia, vAdds );
    Vec_Wec_t * vMap   = Gia_PolynComputeMap( vAdds, Gia_ManObjNum(pGia) );
    Vec_Wec_t * vRes   = Vec_WecStart( Vec_IntSize(vRootBoxes) );
    Vec_Int_t * vRoots = Vec_IntAlloc( 64 );
    Vec_Int_t * vOrder;
    int i, iBox;
    Vec_IntForEachEntry( vRootBoxes, iBox, i )
    {
        Gia_PolyCollectRoots( vAdds, vMap, vMarks, iBox, vRoots );
        vOrder = Gia_PolynCoreOrder_int( pGia, vAdds, vMap, vRoots, NULL );
        Vec_IntAppend( Vec_WecEntry(vRes, i), vOrder );
        Vec_IntFree( vOrder );
    }
    Vec_BitFree( vMarks );
    Vec_IntFree( vRoots );
    Vec_WecFree( vMap );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function: