acecFadds.c File Reference

#include "acecInt.h"
#include "misc/vec/vecWec.h"
#include "misc/tim/tim.h"

Include dependency graph for acecFadds.c:

Go to the source code of this file.

Macros
#define	Dtc_ForEachCut(pList, pCut, i)
	DECLARATIONS ///.
#define	Dtc_ForEachFadd(vFadds, i)

Functions
Vec_Int_t *	Gia_ManDetectHalfAdders (Gia_Man_t *p, int fVerbose)
	FUNCTION DEFINITIONS ///.
void	Gia_ManIllustrateBoxes (Gia_Man_t *p)
int	Dtc_ManCutMergeOne (int *pCut0, int *pCut1, int *pCut)
int	Dtc_ManCutCheckEqual (Vec_Int_t *vCuts, int *pCutNew)
int	Dtc_ObjComputeTruth_rec (Gia_Obj_t *pObj)
void	Dtc_ObjCleanTruth_rec (Gia_Obj_t *pObj)
int	Dtc_ObjComputeTruth (Gia_Man_t *p, int iObj, int *pCut, int *pTruth)
void	Dtc_ManCutMerge (Gia_Man_t *p, int iObj, int *pList0, int *pList1, Vec_Int_t *vCuts, Vec_Int_t *vCutsXor2, Vec_Int_t *vCutsXor, Vec_Int_t *vCutsMaj)
void	Dtc_ManComputeCuts (Gia_Man_t *p, Vec_Int_t **pvCutsXor2, Vec_Int_t **pvCutsXor, Vec_Int_t **pvCutsMaj, int fVerbose)
Vec_Int_t *	Dtc_ManFindCommonCuts (Gia_Man_t *p, Vec_Int_t *vCutsXor, Vec_Int_t *vCutsMaj)
void	Dtc_ManPrintFadds (Vec_Int_t *vFadds)
int	Dtc_ManCompare (int *pCut0, int *pCut1)
int	Dtc_ManCompare2 (int *pCut0, int *pCut1)
Vec_Int_t *	Gia_ManDetectFullAdders (Gia_Man_t *p, int fVerbose, Vec_Int_t **pvCutsXor2)
void	Gia_ManDetectFullAdders2 (Gia_Man_t *p, int fVerbose)
Vec_Int_t *	Gia_ManCreateMap (Gia_Man_t *p, Vec_Int_t *vFadds)
int	Gia_ManFindChains_rec (Gia_Man_t *p, int iMaj, Vec_Int_t *vFadds, Vec_Int_t *vMap, Vec_Int_t *vLength)
void	Gia_ManFindChains (Gia_Man_t *p, Vec_Int_t *vFadds, Vec_Int_t *vMap)
void	Gia_ManCollectOneChain (Gia_Man_t *p, Vec_Int_t *vFadds, int iFaddTop, Vec_Int_t *vMap, Vec_Int_t *vChain)
void	Gia_ManMarkWithTravId_rec (Gia_Man_t *p, int Id)
Vec_Wec_t *	Gia_ManCollectTopmost (Gia_Man_t *p, Vec_Int_t *vFadds, Vec_Int_t *vMap, int nFaddMin)
void	Gia_ManPrintChains (Gia_Man_t *p, Vec_Int_t *vFadds, Vec_Int_t *vMap, Vec_Wec_t *vChains)
Vec_Int_t *	Gia_ManFindMapping (Gia_Man_t *p, Vec_Int_t *vFadds, Vec_Int_t *vMap, Vec_Wec_t *vChains)
Vec_Int_t *	Gia_ManCollectTruthTables (Gia_Man_t *p, Vec_Int_t *vFadds)
float *	Gia_ManGenerateDelayTableFloat (int nIns, int nOuts)
Tim_Man_t *	Gia_ManGenerateTim (int nPis, int nPos, int nBoxes, int nIns, int nOuts)
Gia_Man_t *	Gia_ManGenerateExtraAig (int nBoxes, int nIns, int nOuts)
void	Gia_ManDupFadd (Gia_Man_t *pNew, Gia_Man_t *p, Vec_Int_t *vChain, Vec_Int_t *vFadds, Vec_Int_t *vMap, Vec_Wec_t *vChains, Vec_Int_t *vMap2Chain, Vec_Int_t *vTruths)
void	Gia_ManDupWithFaddBoxes_rec (Gia_Man_t *pNew, Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vFadds, Vec_Int_t *vMap, Vec_Wec_t *vChains, Vec_Int_t *vMap2Chain, Vec_Int_t *vTruths)
Gia_Man_t *	Gia_ManDupWithNaturalBoxes (Gia_Man_t *p, int nFaddMin, int fVerbose)
int	Gia_ObjFanin0CopyCarry (Vec_Int_t *vCarries, Gia_Obj_t *pObj, int Id)
int	Gia_ObjFanin1CopyCarry (Vec_Int_t *vCarries, Gia_Obj_t *pObj, int Id)
Gia_Man_t *	Gia_ManDupWithArtificalFaddBoxes (Gia_Man_t *p, int fUseFanout, int fXorTrick)
Gia_Man_t *	Gia_ManDupWithArtificalFaddBoxesTest (Gia_Man_t *p)
int	Gia_ManFindAnnotatedDelay (Gia_Man_t *p, int DelayC, int *pnBoxes, int fIgnoreBoxDelays)
int	Gia_ManFindChainStart (Gia_Man_t *p)
int	Gia_ManFindPath (Gia_Man_t *p, int DelayC, int nPathMin, int nPathMax, Vec_Int_t *vPath)
int	Gia_ManIteratePaths (Gia_Man_t *p, int DelayC, int nPathMin, int nPathMax, int nPathLimit, int fIgnoreBoxDelays, int fVerbose)
Gia_Man_t *	Gia_ManDupWithArtificialBoxes (Gia_Man_t *p, int DelayC, int nPathMin, int nPathMax, int nPathLimit, int fUseFanout, int fXorTrick, int fIgnoreBoxDelays, int fVerbose)

Macro Definition Documentation

Dtc_ForEachCut

#define Dtc_ForEachCut	(		pList,
			pCut,
			i )

Value:

for ( i = 0, pCut = pList + 1; i < pList[0]; i++, pCut += pCut[0] + 1 )

DECLARATIONS ///.

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

FileName [acecFadds.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [CEC for arithmetic circuits.]

Synopsis [Detecting half-adders and full-adders.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 32 of file acecFadds.c.

Dtc_ForEachFadd

#define Dtc_ForEachFadd	(		vFadds,
			i )

Value:

for ( i = 0; i < Vec_IntSize(vFadds)/5; i++ )

Definition at line 33 of file acecFadds.c.

Function Documentation

Dtc_ManCompare()

int Dtc_ManCompare	(	int *	pCut0,
		int *	pCut1 )

Definition at line 425 of file acecFadds.c.

{
    if ( pCut0[0] < pCut1[0] ) return -1;
    if ( pCut0[0] > pCut1[0] ) return  1;
    if ( pCut0[1] < pCut1[1] ) return -1;
    if ( pCut0[1] > pCut1[1] ) return  1;
    if ( pCut0[2] < pCut1[2] ) return -1;
    if ( pCut0[2] > pCut1[2] ) return  1;
    return 0;
}

Here is the caller graph for this function:

Dtc_ManCompare2()

int Dtc_ManCompare2	(	int *	pCut0,
		int *	pCut1 )

Definition at line 435 of file acecFadds.c.

{
    if ( pCut0[4] < pCut1[4] ) return -1;
    if ( pCut0[4] > pCut1[4] ) return  1;
    return 0;
}

Here is the caller graph for this function:

Dtc_ManComputeCuts()

void Dtc_ManComputeCuts	(	Gia_Man_t *	p,
		Vec_Int_t **	pvCutsXor2,
		Vec_Int_t **	pvCutsXor,
		Vec_Int_t **	pvCutsMaj,
		int	fVerbose )

Definition at line 335 of file acecFadds.c.

{
    Gia_Obj_t * pObj; 
    int * pList0, * pList1, i, nCuts = 0;
    Vec_Int_t * vTemp = Vec_IntAlloc( 1000 );
    Vec_Int_t * vCutsXor2 = Vec_IntAlloc( Gia_ManAndNum(p) );
    Vec_Int_t * vCutsXor = Vec_IntAlloc( Gia_ManAndNum(p) );
    Vec_Int_t * vCutsMaj = Vec_IntAlloc( Gia_ManAndNum(p) );
    Vec_Int_t * vCuts = Vec_IntAlloc( 30 * Gia_ManAndNum(p) );
    Vec_IntFill( vCuts, Gia_ManObjNum(p), 0 );
    Gia_ManCleanValue( p );
    Gia_ManForEachCi( p, pObj, i )
    {
        Vec_IntWriteEntry( vCuts, Gia_ObjId(p, pObj), Vec_IntSize(vCuts) );
        Vec_IntPush( vCuts, 1 );
        Vec_IntPush( vCuts, 1 );
        Vec_IntPush( vCuts, Gia_ObjId(p, pObj) );
    }
    Gia_ManForEachAnd( p, pObj, i )
    {
        pList0 = Vec_IntEntryP( vCuts, Vec_IntEntry(vCuts, Gia_ObjFaninId0(pObj, i)) );
        pList1 = Vec_IntEntryP( vCuts, Vec_IntEntry(vCuts, Gia_ObjFaninId1(pObj, i)) );
        Dtc_ManCutMerge( p, i, pList0, pList1, vTemp, vCutsXor2, vCutsXor, vCutsMaj );
        Vec_IntWriteEntry( vCuts, i, Vec_IntSize(vCuts) );
        Vec_IntAppend( vCuts, vTemp );
        nCuts += Vec_IntEntry( vTemp, 0 );
    }
    if ( fVerbose )
        printf( "Nodes = %d.  Cuts = %d.  Cuts/Node = %.2f.  Ints/Node = %.2f.\n", 
            Gia_ManAndNum(p), nCuts, 1.0*nCuts/Gia_ManAndNum(p), 1.0*Vec_IntSize(vCuts)/Gia_ManAndNum(p) );
    Vec_IntFree( vTemp );
    Vec_IntFree( vCuts );
    if ( pvCutsXor2 )
        *pvCutsXor2 = vCutsXor2;
    else
        Vec_IntFree( vCutsXor2 );
    *pvCutsXor = vCutsXor;
    *pvCutsMaj = vCutsMaj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dtc_ManCutCheckEqual()

int Dtc_ManCutCheckEqual	(	Vec_Int_t *	vCuts,
		int *	pCutNew )

Definition at line 217 of file acecFadds.c.

{
    int * pList = Vec_IntArray( vCuts );
    int i, k, * pCut;
    Dtc_ForEachCut( pList, pCut, i )
    {
        for ( k = 0; k <= pCut[0]; k++ )
            if ( pCut[k] != pCutNew[k] )
                break;
        if ( k > pCut[0] )
            return 1;
    }
    return 0;
}

Here is the caller graph for this function:

Dtc_ManCutMerge()

void Dtc_ManCutMerge	(	Gia_Man_t *	p,
		int	iObj,
		int *	pList0,
		int *	pList1,
		Vec_Int_t *	vCuts,
		Vec_Int_t *	vCutsXor2,
		Vec_Int_t *	vCutsXor,
		Vec_Int_t *	vCutsMaj )

Definition at line 272 of file acecFadds.c.

{
    int fVerbose = 0;
    Vec_Int_t * vTemp;
    int i, k, c, Type, * pCut0, * pCut1, pCut[4];
    if ( fVerbose )
        printf( "Object %d = :\n", iObj );
    Vec_IntFill( vCuts, 2, 1 );
    Vec_IntPush( vCuts, iObj );
    Dtc_ForEachCut( pList0, pCut0, i )
    Dtc_ForEachCut( pList1, pCut1, k )
    {
        if ( !Dtc_ManCutMergeOne(pCut0, pCut1, pCut) )
            continue;
        if ( Dtc_ManCutCheckEqual(vCuts, pCut) )
            continue;
        Vec_IntAddToEntry( vCuts, 0, 1 );  
        if ( fVerbose )
            printf( "%d : ", pCut[0] );
        for ( c = 0; c <= pCut[0]; c++ )
        {
            Vec_IntPush( vCuts, pCut[c] );
            if ( fVerbose && c )
                printf( "%d ", pCut[c] );
        }
        if ( fVerbose )
            printf( "\n" );
        if ( pCut[0] == 2 )
        {
            int Value = Dtc_ObjComputeTruth( p, iObj, pCut, NULL );
            assert( Value == 3 || Value == 0 );
            if ( Value == 3 )
            {
                Vec_IntPush( vCutsXor2, pCut[1] );
                Vec_IntPush( vCutsXor2, pCut[2] );
                Vec_IntPush( vCutsXor2, iObj );
            }
            continue;
        }
        if ( pCut[0] != 3 )
            continue;
        Type = Dtc_ObjComputeTruth( p, iObj, pCut, NULL );
        if ( Type == 0 )
            continue;
        vTemp = Type == 1 ? vCutsXor : vCutsMaj;
        if ( 0 && Type == 2 )
        {
            fVerbose = 1;
            if ( fVerbose )
                printf( "%d = %s(", iObj, Type == 1 ? "XOR" : "MAJ" );
            for ( c = 1; c <= pCut[0]; c++ )
            {
                if ( fVerbose )
                    printf( " %d", pCut[c] );
                Vec_IntPush( vTemp, pCut[c] );
            }
            if ( fVerbose )
                printf( " )\n" );
            fVerbose = 0;
        }
        Vec_IntPush( vTemp, iObj );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dtc_ManCutMergeOne()

int Dtc_ManCutMergeOne	(	int *	pCut0,
		int *	pCut1,
		int *	pCut )

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

Synopsis [Detecting FADDs in the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 187 of file acecFadds.c.

{
    int i, k;
    for ( k = 0; k <= pCut1[0]; k++ )
        pCut[k] = pCut1[k];
    for ( i = 1; i <= pCut0[0]; i++ )
    {
        for ( k = 1; k <= pCut1[0]; k++ )
            if ( pCut0[i] == pCut1[k] )
                break;
        if ( k <= pCut1[0] )
            continue;
        if ( pCut[0] == 3 )
            return 0;
        pCut[1+pCut[0]++] = pCut0[i];
    }
    assert( pCut[0] == 2 || pCut[0] == 3 );
    if ( pCut[1] > pCut[2] )
        ABC_SWAP( int, pCut[1], pCut[2] );
    assert( pCut[1] < pCut[2] );
    if ( pCut[0] == 2 )
        return 1;
    if ( pCut[2] > pCut[3] )
        ABC_SWAP( int, pCut[2], pCut[3] );
    if ( pCut[1] > pCut[2] )
        ABC_SWAP( int, pCut[1], pCut[2] );
    assert( pCut[1] < pCut[2] );
    assert( pCut[2] < pCut[3] );
    return 1;
}

Here is the caller graph for this function:

Dtc_ManFindCommonCuts()

Vec_Int_t * Dtc_ManFindCommonCuts	(	Gia_Man_t *	p,
		Vec_Int_t *	vCutsXor,
		Vec_Int_t *	vCutsMaj )

Definition at line 374 of file acecFadds.c.

{
    int * pCuts0 = Vec_IntArray(vCutsXor);
    int * pCuts1 = Vec_IntArray(vCutsMaj);
    int * pLimit0 = Vec_IntLimit(vCutsXor);
    int * pLimit1 = Vec_IntLimit(vCutsMaj);   int i;
    Vec_Int_t * vFadds = Vec_IntAlloc( 1000 );
    assert( Vec_IntSize(vCutsXor) % 4 == 0 );
    assert( Vec_IntSize(vCutsMaj) % 4 == 0 );
    while ( pCuts0 < pLimit0 && pCuts1 < pLimit1 )
    {
        for ( i = 0; i < 3; i++ )
            if ( pCuts0[i] != pCuts1[i] )
                break;
        if ( i == 3 )
        {
            for ( i = 0; i < 4; i++ )
                Vec_IntPush( vFadds, pCuts0[i] );
            Vec_IntPush( vFadds, pCuts1[3] );
            pCuts0 += 4;
            pCuts1 += 4;
        }
        else if ( pCuts0[i] < pCuts1[i] )
            pCuts0 += 4;
        else if ( pCuts0[i] > pCuts1[i] )
            pCuts1 += 4;
    }
    assert( Vec_IntSize(vFadds) % 5 == 0 );
    return vFadds;
}

Here is the caller graph for this function:

Dtc_ManPrintFadds()

void Dtc_ManPrintFadds

(

Vec_Int_t *

vFadds

)

Definition at line 404 of file acecFadds.c.

{
    int i;
    Dtc_ForEachFadd( vFadds, i )
    {
        printf( "%6d : ", i );
        printf( "%6d ", Vec_IntEntry(vFadds, 5*i+0) );
        printf( "%6d ", Vec_IntEntry(vFadds, 5*i+1) );
        printf( "%6d ", Vec_IntEntry(vFadds, 5*i+2) );
        printf( " ->  " );
        printf( "%6d ", Vec_IntEntry(vFadds, 5*i+3) );
        printf( "%6d ", Vec_IntEntry(vFadds, 5*i+4) );
        printf( "\n" );
 
        if ( i == 100 )
        {
            printf( "Skipping other FADDs.\n" );
            break;
        }
    }
}

Here is the caller graph for this function:

Dtc_ObjCleanTruth_rec()

void Dtc_ObjCleanTruth_rec

(

Gia_Obj_t *

pObj

)

Definition at line 244 of file acecFadds.c.

{
    if ( !pObj->Value )
        return;
    pObj->Value = 0;
    if ( !Gia_ObjIsAnd(pObj) )
        return;
    Dtc_ObjCleanTruth_rec( Gia_ObjFanin0(pObj) );
    Dtc_ObjCleanTruth_rec( Gia_ObjFanin1(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dtc_ObjComputeTruth()

int Dtc_ObjComputeTruth	(	Gia_Man_t *	p,
		int	iObj,
		int *	pCut,
		int *	pTruth )

Definition at line 254 of file acecFadds.c.

{
    unsigned Truth, Truths[3] = { 0xAA, 0xCC, 0xF0 }; int i;
    for ( i = 1; i <= pCut[0]; i++ )
        Gia_ManObj(p, pCut[i])->Value = Truths[i-1];
    Truth = 0xFF & Dtc_ObjComputeTruth_rec( Gia_ManObj(p, iObj) );
    Dtc_ObjCleanTruth_rec( Gia_ManObj(p, iObj) );
    if ( pTruth ) 
        *pTruth = Truth;
    if ( Truth == 0x66 || Truth == 0x99 )
        return 3;
    if ( Truth == 0x96 || Truth == 0x69 )
        return 1;
    if ( Truth == 0xE8 || Truth == 0xD4 || Truth == 0xB2 || Truth == 0x71 ||
         Truth == 0x17 || Truth == 0x2B || Truth == 0x4D || Truth == 0x8E )
        return 2;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dtc_ObjComputeTruth_rec()

int Dtc_ObjComputeTruth_rec

(

Gia_Obj_t *

pObj

)

Definition at line 231 of file acecFadds.c.

{
    int Truth0, Truth1;
    if ( pObj->Value )
        return pObj->Value;
    assert( Gia_ObjIsAnd(pObj) );
    Truth0 = Dtc_ObjComputeTruth_rec( Gia_ObjFanin0(pObj) );
    Truth1 = Dtc_ObjComputeTruth_rec( Gia_ObjFanin1(pObj) );
    if ( Gia_ObjIsXor(pObj) )
        return (pObj->Value = (Gia_ObjFaninC0(pObj) ? ~Truth0 : Truth0) ^ (Gia_ObjFaninC1(pObj) ? ~Truth1 : Truth1));
    else
        return (pObj->Value = (Gia_ObjFaninC0(pObj) ? ~Truth0 : Truth0) & (Gia_ObjFaninC1(pObj) ? ~Truth1 : Truth1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCollectOneChain()

void Gia_ManCollectOneChain	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds,
		int	iFaddTop,
		Vec_Int_t *	vMap,
		Vec_Int_t *	vChain )

Definition at line 530 of file acecFadds.c.

{
    int iFadd;
    Vec_IntClear( vChain );
    for ( iFadd = iFaddTop; iFadd >= 0 && 
          !Gia_ObjIsTravIdCurrentId(p, Vec_IntEntry(vFadds, 5*iFadd+3)) && 
          !Gia_ObjIsTravIdCurrentId(p, Vec_IntEntry(vFadds, 5*iFadd+4)); 
          iFadd = Vec_IntEntry(vMap, Vec_IntEntry(vFadds, 5*iFadd+0)) )
          {
                Vec_IntPush( vChain, iFadd );
          }
    Vec_IntReverseOrder( vChain );
}

Here is the caller graph for this function:

Gia_ManCollectTopmost()

Vec_Wec_t * Gia_ManCollectTopmost	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap,
		int	nFaddMin )

Definition at line 556 of file acecFadds.c.

{
    int i, j, iFadd;
    Vec_Int_t * vChain  = Vec_IntAlloc( 100 );
    Vec_Wec_t * vChains = Vec_WecAlloc( Vec_IntSize(vFadds)/5 );
    // erase elements appearing as FADD inputs
    Vec_Bit_t * vMarksTop = Vec_BitStart( Vec_IntSize(vFadds)/5 );
    Dtc_ForEachFadd( vFadds, i )
        if ( (iFadd = Vec_IntEntry(vMap, Vec_IntEntry(vFadds, 5*i+0))) >= 0 )
            Vec_BitWriteEntry( vMarksTop, iFadd, 1 );
    // compress the remaining ones
    Gia_ManIncrementTravId( p );
    Dtc_ForEachFadd( vFadds, i )
    {
        if ( Vec_BitEntry(vMarksTop, i) )
            continue;
        Gia_ManCollectOneChain( p, vFadds, i, vMap, vChain );
        if ( Vec_IntSize(vChain) < nFaddMin )
            continue;
        Vec_IntAppend( Vec_WecPushLevel(vChains), vChain );
        Vec_IntForEachEntry( vChain, iFadd, j )
        {
            assert( !Gia_ObjIsTravIdCurrentId(p, Vec_IntEntry(vFadds, 5*iFadd+3)) );
            assert( !Gia_ObjIsTravIdCurrentId(p, Vec_IntEntry(vFadds, 5*iFadd+4)) );
            Gia_ManMarkWithTravId_rec( p, Vec_IntEntry(vFadds, 5*iFadd+3) );
            Gia_ManMarkWithTravId_rec( p, Vec_IntEntry(vFadds, 5*iFadd+4) );
        }
    }
    // cleanup
    Vec_BitFree( vMarksTop );
    Vec_IntFree( vChain );
    return vChains;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCollectTruthTables()

Vec_Int_t * Gia_ManCollectTruthTables	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds )

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

Synopsis [Derive GIA with boxes containing adder-chains.]

Description []

SideEffects []

SeeAlso []

Definition at line 652 of file acecFadds.c.

{
    int i, k, Type, Truth, pCut[4] = {3};
    Vec_Int_t * vTruths = Vec_IntAlloc( 2*Vec_IntSize(vFadds)/5 );
    Gia_ManCleanValue( p );
    Dtc_ForEachFadd( vFadds, i )
    {
        for ( k = 0; k < 3; k++ )
            pCut[k+1] = Vec_IntEntry( vFadds, 5*i+k );
        Type = Dtc_ObjComputeTruth( p, Vec_IntEntry(vFadds, 5*i+3), pCut, &Truth );
        assert( Type == 1 );
        Vec_IntPush( vTruths, Truth );
        Type = Dtc_ObjComputeTruth( p, Vec_IntEntry(vFadds, 5*i+4), pCut, &Truth );
        assert( Type == 2 );
        Vec_IntPush( vTruths, Truth );
    }
    return vTruths;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCreateMap()

Vec_Int_t * Gia_ManCreateMap	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds )

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

Synopsis [Map each MAJ into the topmost MAJ of its chain.]

Description []

SideEffects []

SeeAlso []

Definition at line 481 of file acecFadds.c.

{
    Vec_Int_t * vMap = Vec_IntStartFull( Gia_ManObjNum(p) );  int i;
    Dtc_ForEachFadd( vFadds, i )
        Vec_IntWriteEntry( vMap, Vec_IntEntry(vFadds, 5*i+4), i );
    return vMap;
}

Here is the caller graph for this function:

Gia_ManDetectFullAdders()

Vec_Int_t * Gia_ManDetectFullAdders	(	Gia_Man_t *	p,
		int	fVerbose,
		Vec_Int_t **	pvCutsXor2 )

Definition at line 442 of file acecFadds.c.

{
    Vec_Int_t * vCutsXor, * vCutsMaj, * vFadds;
    Dtc_ManComputeCuts( p, pvCutsXor2, &vCutsXor, &vCutsMaj, fVerbose );
    qsort( Vec_IntArray(vCutsXor), (size_t)(Vec_IntSize(vCutsXor)/4), 16, (int (*)(const void *, const void *))Dtc_ManCompare );
    qsort( Vec_IntArray(vCutsMaj), (size_t)(Vec_IntSize(vCutsMaj)/4), 16, (int (*)(const void *, const void *))Dtc_ManCompare );
    vFadds = Dtc_ManFindCommonCuts( p, vCutsXor, vCutsMaj );
    qsort( Vec_IntArray(vFadds), (size_t)(Vec_IntSize(vFadds)/5), 20, (int (*)(const void *, const void *))Dtc_ManCompare2 );
    if ( fVerbose )
        printf( "XOR3 cuts = %d.  MAJ cuts = %d.  Full-adders = %d.\n", Vec_IntSize(vCutsXor)/4, Vec_IntSize(vCutsMaj)/4, Vec_IntSize(vFadds)/5 );
    if ( fVerbose )
        Dtc_ManPrintFadds( vFadds );
    Vec_IntFree( vCutsXor );
    Vec_IntFree( vCutsMaj );
    return vFadds;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDetectFullAdders2()

void Gia_ManDetectFullAdders2	(	Gia_Man_t *	p,
		int	fVerbose )

Definition at line 458 of file acecFadds.c.

{
    Vec_Int_t * vCutsXor2, * vCutsXor, * vCutsMaj;
    Dtc_ManComputeCuts( p, &vCutsXor2, &vCutsXor, &vCutsMaj, fVerbose );
    if ( fVerbose )
        printf( "XOR3 cuts = %d.  MAJ cuts = %d.\n", Vec_IntSize(vCutsXor)/4, Vec_IntSize(vCutsMaj)/4 );
    Vec_IntFree( vCutsXor2 );
    Vec_IntFree( vCutsXor );
    Vec_IntFree( vCutsMaj );
}

Here is the call graph for this function:

Gia_ManDetectHalfAdders()

Vec_Int_t * Gia_ManDetectHalfAdders	(	Gia_Man_t *	p,
		int	fVerbose )

FUNCTION DEFINITIONS ///.

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

Synopsis [Detecting HADDs in the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 50 of file acecFadds.c.

{
    Vec_Int_t * vHadds = Vec_IntAlloc( 1000 );
    Gia_Obj_t * pObj, * pFan0, * pFan1; 
    int i, iLit, iFan0, iFan1, fComplDiff, Count, Counts[5] = {0};
    Gia_ManHashStart( p );
    if ( p->nXors )
    {
        Gia_ManForEachAnd( p, pObj, i )
        {
            if ( !Gia_ObjIsXor(pObj) )
                continue;
            Count = 0;
            iFan0 = Gia_ObjFaninId0(pObj, i);
            iFan1 = Gia_ObjFaninId1(pObj, i);
            if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 0), Abc_Var2Lit(iFan1, 0))) )
                Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
            if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 1), Abc_Var2Lit(iFan1, 1))) )
                Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
            if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 0), Abc_Var2Lit(iFan1, 1))) )
                Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
            if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 1), Abc_Var2Lit(iFan1, 0))) )
                Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
            Counts[Count]++;
        }
    }
    else
    {
        ABC_FREE( p->pRefs );
        Gia_ManCreateRefs( p );
        Gia_ManForEachAnd( p, pObj, i )
        {
            if ( !Gia_ObjRecognizeExor(pObj, &pFan0, &pFan1) )
                continue;
            Count = 0;
            if ( Gia_ObjRefNumId(p, Gia_ObjFaninId0(pObj, i)) > 1 )
                Vec_IntPushTwo( vHadds, i, Gia_ObjFaninId0(pObj, i) ), Count++;
            if ( Gia_ObjRefNumId(p, Gia_ObjFaninId1(pObj, i)) > 1 )
                Vec_IntPushTwo( vHadds, i, Gia_ObjFaninId1(pObj, i) ), Count++;
            iFan0 = Gia_ObjId( p, pFan0 );
            iFan1 = Gia_ObjId( p, pFan1 );
            fComplDiff =          (Gia_ObjFaninC0(Gia_ObjFanin0(pObj)) ^ Gia_ObjFaninC1(Gia_ObjFanin0(pObj)));
            assert( fComplDiff == (Gia_ObjFaninC0(Gia_ObjFanin1(pObj)) ^ Gia_ObjFaninC1(Gia_ObjFanin1(pObj))) );
            if ( fComplDiff )
            {
                if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 0), Abc_Var2Lit(iFan1, 0))) )
                    Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
                if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 1), Abc_Var2Lit(iFan1, 1))) )
                    Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
            }
            else
            {
                if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 0), Abc_Var2Lit(iFan1, 1))) )
                    Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
                if ( (iLit = Gia_ManHashLookupInt(p, Abc_Var2Lit(iFan0, 1), Abc_Var2Lit(iFan1, 0))) )
                    Vec_IntPushTwo( vHadds, i, Abc_Lit2Var(iLit) ), Count++;
            }
            Counts[Count]++;
        }
        ABC_FREE( p->pRefs );
    }
    Gia_ManHashStop( p );
    if ( fVerbose )
    {
        int iXor, iAnd;
        printf( "Found %d half-adders with XOR gates: ", Vec_IntSize(vHadds)/2 );
        for ( i = 0; i <= 4; i++ )
            printf( "%d=%d ", i, Counts[i] );
        printf( "\n" );
 
        Vec_IntForEachEntryDouble( vHadds, iXor, iAnd, i )
        {
            pObj = Gia_ManObj( p, iXor );
            printf( "%3d : %5d %5d -> %5d %5d\n", i, Gia_ObjFaninId0(pObj, iXor), Gia_ObjFaninId1(pObj, iXor), iXor, iAnd );
        }
    }
    return vHadds;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDupFadd()

void Gia_ManDupFadd	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p,
		Vec_Int_t *	vChain,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap,
		Vec_Wec_t *	vChains,
		Vec_Int_t *	vMap2Chain,
		Vec_Int_t *	vTruths )

Definition at line 718 of file acecFadds.c.

{
    extern void Gia_ManDupWithFaddBoxes_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vFadds, Vec_Int_t * vMap, Vec_Wec_t * vChains, Vec_Int_t * vMap2Chain, Vec_Int_t * vTruths );
    int i, k, iFadd = -1, iCiLit, pLits[3];
    Gia_Obj_t * pObj;
    // construct FADD inputs
    Vec_IntForEachEntry( vChain, iFadd, i )
        for ( k = 0; k < 3; k++ )
        {
            if ( i && !k ) continue;
            pObj = Gia_ManObj( p, Vec_IntEntry(vFadds, 5*iFadd+k) );
            Gia_ManDupWithFaddBoxes_rec( pNew, p, pObj, vFadds, vMap, vChains, vMap2Chain, vTruths );
        }
    // construct boxes
    iCiLit = 0;
    Vec_IntForEachEntry( vChain, iFadd, i )
    {
        int iXorTruth = Vec_IntEntry( vTruths, 2*iFadd+0 );
        int iMajTruth = Vec_IntEntry( vTruths, 2*iFadd+1 );
        for ( k = 0; k < 3; k++ )
        {
            pObj = Gia_ManObj( p, Vec_IntEntry(vFadds, 5*iFadd+k) );
            pLits[k] = (!k && iCiLit) ? iCiLit : pObj->Value;
            assert( pLits[k] >= 0 );
        }
        // normalize truth table
        //    if ( Truth == 0xE8 || Truth == 0xD4 || Truth == 0xB2 || Truth == 0x71 ||
        //         Truth == 0x17 || Truth == 0x2B || Truth == 0x4D || Truth == 0x8E )
        if ( iMajTruth == 0x4D )
            pLits[0] = Abc_LitNot(pLits[0]), iMajTruth = 0x8E, iXorTruth = 0xFF & ~iXorTruth;
        else if ( iMajTruth == 0xD4 )
            pLits[0] = Abc_LitNot(pLits[0]), iMajTruth = 0xE8, iXorTruth = 0xFF & ~iXorTruth;
        else if ( iMajTruth == 0x2B )
            pLits[1] = Abc_LitNot(pLits[1]), iMajTruth = 0x8E, iXorTruth = 0xFF & ~iXorTruth;
        else if ( iMajTruth == 0xB2 )
            pLits[1] = Abc_LitNot(pLits[1]), iMajTruth = 0xE8, iXorTruth = 0xFF & ~iXorTruth;
        if ( iMajTruth == 0x8E )
            pLits[2] = Abc_LitNot(pLits[2]), iMajTruth = 0xE8, iXorTruth = 0xFF & ~iXorTruth;
        else if ( iMajTruth == 0x71 )
            pLits[2] = Abc_LitNot(pLits[2]), iMajTruth = 0x17, iXorTruth = 0xFF & ~iXorTruth;
        else assert( iMajTruth == 0xE8 || iMajTruth == 0x17 );
        // normalize carry-in
        if ( Abc_LitIsCompl(pLits[0]) )
        {
            for ( k = 0; k < 3; k++ )
                pLits[k] = Abc_LitNot(pLits[k]);
            iXorTruth = 0xFF & ~iXorTruth;
            iMajTruth = 0xFF & ~iMajTruth;
        }
        // add COs
        assert( !Abc_LitIsCompl(pLits[0]) );
        for ( k = 0; k < 3; k++ )
            Gia_ManAppendCo( pNew, pLits[k] );
        // create CI
        assert( iXorTruth == 0x96 || iXorTruth == 0x69 );
        pObj = Gia_ManObj( p, Vec_IntEntry(vFadds, 5*iFadd+3) );
        pObj->Value = Abc_LitNotCond( Gia_ManAppendCi(pNew), (int)(iXorTruth == 0x69) );
        // create CI
        assert( iMajTruth == 0xE8 || iMajTruth == 0x17 );
        iCiLit = Abc_LitNotCond( Gia_ManAppendCi(pNew), (int)(iMajTruth == 0x17) );
    }   
    // assign carry out
    assert( iFadd == Vec_IntEntryLast(vChain) );
    pObj = Gia_ManObj( p, Vec_IntEntry(vFadds, 5*iFadd+4) );
    pObj->Value = iCiLit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDupWithArtificalFaddBoxes()

Gia_Man_t * Gia_ManDupWithArtificalFaddBoxes	(	Gia_Man_t *	p,
		int	fUseFanout,
		int	fXorTrick )

Definition at line 921 of file acecFadds.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;  
    int nBoxes = Gia_ManBoxNum(p);
    int i, nRealPis, nRealPos;
    Vec_Int_t * vCarries = NULL;
    // make sure two chains do not overlap
    Gia_ManCleanPhase( p );
    Gia_ManForEachCi( p, pObj, i )
        assert( !pObj->fMark0 && !pObj->fMark1 );
    Gia_ManForEachCo( p, pObj, i )
        assert( !pObj->fMark0 && !pObj->fMark1 );
    Gia_ManForEachAnd( p, pObj, i )
    {
        assert( !pObj->fMark0 || !pObj->fMark1 );
        if ( pObj->fMark0 )
        {
            assert( Gia_ObjFanin0(pObj)->fPhase == 0 );
            Gia_ObjFanin0(pObj)->fPhase = 1;
        }
        if ( pObj->fMark1 )
        {
            assert( Gia_ObjFanin1(pObj)->fPhase == 0 );
            Gia_ObjFanin1(pObj)->fPhase = 1;
        }
    }
    // create mapping for carry-chains
    if ( !fUseFanout )
        vCarries = Vec_IntStartFull( Gia_ManObjNum(p) );
    // create references and discount carries
    if ( vCarries )
    {
        Gia_ManCreateRefs( p );
        Gia_ManForEachAnd( p, pObj, i )
            if ( pObj->fMark0 )
                Gia_ObjRefFanin0Dec( p, pObj );
            else if ( pObj->fMark1 )
                Gia_ObjRefFanin1Dec( p, pObj );
    }
    // if AIG already has (natural) FADD boxes, it should not un-normalized
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( !pObj->fMark0 && !pObj->fMark1 ) // AND-gate
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else // AND-gate with chain
        {
            int iCiLit, iOtherLit, iLit0, iLit1, iLit2, iXorLit;
            assert( pObj->fMark0 != pObj->fMark1 );
            iCiLit    = pObj->fMark0 ? Gia_ObjFanin0CopyCarry(vCarries, pObj, i) : Gia_ObjFanin1CopyCarry(vCarries, pObj, i);
            iOtherLit = pObj->fMark0 ? Gia_ObjFanin1Copy(pObj) : Gia_ObjFanin0Copy(pObj);
            assert( iCiLit >= 0 && iOtherLit >= 0 );
            iLit0 = Abc_LitNotCond( iCiLit,    Abc_LitIsCompl(iCiLit) );
            iLit1 = Abc_LitNotCond( iOtherLit, Abc_LitIsCompl(iCiLit) );
            iLit2 = Abc_LitNotCond( 0,         Abc_LitIsCompl(iCiLit) );
            // add COs
            assert( !Abc_LitIsCompl(iLit0) );
            Gia_ManAppendCo( pNew, iLit0 );
            Gia_ManAppendCo( pNew, iLit1 );
            Gia_ManAppendCo( pNew, iLit2 );
            // add CI (unused sum bit)
            iXorLit = Gia_ManAppendCi(pNew);
            // add CI (carry bit)
            pObj->Value = Abc_LitNotCond( Gia_ManAppendCi(pNew), Abc_LitIsCompl(iCiLit) );
            if ( vCarries && pObj->fPhase )
            {
                Vec_IntWriteEntry( vCarries, i, pObj->Value );
                if ( Gia_ObjRefNum(p, pObj) > 0 )
                {
                    if ( fXorTrick )
                        pObj->Value = Gia_ManAppendAnd( pNew, Abc_LitNotCond(iXorLit, !Abc_LitIsCompl(iCiLit)), iOtherLit );
                    else
                        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
                }
            }
            nBoxes++;
        }
    }
    Gia_ManCleanPhase( p );
    Vec_IntFreeP( &vCarries );
    ABC_FREE( p->pRefs );
    assert( !Gia_ManHasDangling(pNew) );
    // other information
//    nBoxes += (Gia_ManCiNum(pNew) - Gia_ManCiNum(p)) / 2;
//    assert( nBoxes == Gia_ManBoxNum(p) + (Gia_ManCoNum(pNew) - Gia_ManCoNum(p)) / 3 );
    nRealPis = Gia_ManBoxNum(p) ? Tim_ManPiNum((Tim_Man_t *)p->pManTime) : Gia_ManCiNum(p);
    nRealPos = Gia_ManBoxNum(p) ? Tim_ManPoNum((Tim_Man_t *)p->pManTime) : Gia_ManCoNum(p);
    pNew->pManTime  = Gia_ManGenerateTim( nRealPis, nRealPos, nBoxes, 3, 2 );
    pNew->pAigExtra = Gia_ManGenerateExtraAig( nBoxes, 3, 2 );
    // optionally normalize the AIG
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDupWithArtificalFaddBoxesTest()

Gia_Man_t * Gia_ManDupWithArtificalFaddBoxesTest

(

Gia_Man_t *

p

)

Definition at line 1022 of file acecFadds.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    // label some and-gates
    Gia_ManCleanMark01( p );
    Gia_ManForEachAnd( p, pObj, i )
    {
        pObj->fMark0 = i % 5;
        pObj->fMark1 = i % 7;
        if ( pObj->fMark0 && pObj->fMark1 )
            pObj->fMark0 = pObj->fMark1 = 0;
    }
 
    // output new AIG
    pNew = Gia_ManDupWithArtificalFaddBoxes( p, 0, 0 );
    Gia_ManCleanMark01( p );
    return pNew;
}

Here is the call graph for this function:

Gia_ManDupWithArtificialBoxes()

Gia_Man_t * Gia_ManDupWithArtificialBoxes	(	Gia_Man_t *	p,
		int	DelayC,
		int	nPathMin,
		int	nPathMax,
		int	nPathLimit,
		int	fUseFanout,
		int	fXorTrick,
		int	fIgnoreBoxDelays,
		int	fVerbose )

Definition at line 1240 of file acecFadds.c.

{
    Gia_Man_t * pNew;
/*
    if ( Gia_ManBoxNum(p) > 0 )
    {
        printf( "Currently artifical carry-chains cannot be detected when natural ones are present.\n" );
        return NULL;
    }
*/
    Gia_ManIteratePaths( p, DelayC, nPathMin, nPathMax, nPathLimit, fIgnoreBoxDelays, fVerbose );
    pNew = Gia_ManDupWithArtificalFaddBoxes( p, fUseFanout, fXorTrick );
    Gia_ManCleanMark01( p );
    return pNew;
}

Here is the call graph for this function:

Gia_ManDupWithFaddBoxes_rec()

void Gia_ManDupWithFaddBoxes_rec	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap,
		Vec_Wec_t *	vChains,
		Vec_Int_t *	vMap2Chain,
		Vec_Int_t *	vTruths )

Definition at line 784 of file acecFadds.c.

{
    int iChain;
    if ( ~pObj->Value )
        return;
    assert( Gia_ObjIsAnd(pObj) );
    iChain = Vec_IntEntry( vMap2Chain, Gia_ObjId(p, pObj) );
/*
    assert( iChain == -1 );
    if ( iChain >= 0 )
    {
        Gia_ManDupFadd( pNew, p, Vec_WecEntry(vChains, iChain), vFadds, vMap, vChains, vMap2Chain, vTruths );
        assert( ~pObj->Value );
        return;
    }
*/
    Gia_ManDupWithFaddBoxes_rec( pNew, p, Gia_ObjFanin0(pObj), vFadds, vMap, vChains, vMap2Chain, vTruths );
    Gia_ManDupWithFaddBoxes_rec( pNew, p, Gia_ObjFanin1(pObj), vFadds, vMap, vChains, vMap2Chain, vTruths );
    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDupWithNaturalBoxes()

Gia_Man_t * Gia_ManDupWithNaturalBoxes	(	Gia_Man_t *	p,
		int	nFaddMin,
		int	fVerbose )

Definition at line 804 of file acecFadds.c.

{
    abctime clk = Abc_Clock();
    Gia_Man_t * pNew;//, * pTemp;
    Vec_Int_t * vFadds, * vMap, * vMap2Chain, * vTruths, * vChain;
    Vec_Wec_t * vChains;
    Gia_Obj_t * pObj;  
    int i, nBoxes;
    if ( Gia_ManBoxNum(p) > 0 )
    {
        printf( "Currently natural carry-chains cannot be detected when boxes are present.\n" );
        return NULL;
    }
    assert( Gia_ManBoxNum(p) == 0 );
 
    // detect FADDs
    vFadds = Gia_ManDetectFullAdders( p, fVerbose, NULL );
    assert( Vec_IntSize(vFadds) % 5 == 0 );
    // map MAJ into its FADD
    vMap = Gia_ManCreateMap( p, vFadds );
    // for each FADD, find the longest chain and reorder its inputs
    Gia_ManFindChains( p, vFadds, vMap );
    // returns the set of topmost MAJ nodes
    vChains = Gia_ManCollectTopmost( p, vFadds, vMap, nFaddMin );
    if ( fVerbose )
        Gia_ManPrintChains( p, vFadds, vMap, vChains );
    if ( Vec_WecSize(vChains) == 0 )
    {
        Vec_IntFree( vFadds );
        Vec_IntFree( vMap );
        Vec_WecFree( vChains );
        return Gia_ManDup( p );
    }
    // returns mapping of each MAJ into the topmost elements of its chain
    vMap2Chain = Gia_ManFindMapping( p, vFadds, vMap, vChains );
    // compute truth tables for FADDs
    vTruths = Gia_ManCollectTruthTables( p, vFadds );
    if ( fVerbose )
        Abc_PrintTime( 1, "Carry-chain detection time", Abc_Clock() - clk );
 
    // duplicate
    clk = Abc_Clock();
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Vec_WecForEachLevel( vChains, vChain, i )
        Gia_ManDupFadd( pNew, p, vChain, vFadds, vMap, vChains, vMap2Chain, vTruths );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupWithFaddBoxes_rec( pNew, p, Gia_ObjFanin0(pObj), vFadds, vMap, vChains, vMap2Chain, vTruths );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    if ( Gia_ManRegNum(p) )
    {
        if ( fVerbose )
            printf( "Warning: Sequential design is converted into combinational one by adding white boxes.\n" );
        pNew->nRegs = 0;
    }
    assert( !Gia_ManHasDangling(pNew) );
 
    // cleanup
    Vec_IntFree( vFadds );
    Vec_IntFree( vMap );
    Vec_WecFree( vChains );
    Vec_IntFree( vMap2Chain );
    Vec_IntFree( vTruths );
    
    // other information
    nBoxes = (Gia_ManCiNum(pNew) - Gia_ManCiNum(p)) / 2;
    assert( nBoxes == (Gia_ManCoNum(pNew) - Gia_ManCoNum(p)) / 3 );
    pNew->pManTime  = Gia_ManGenerateTim( Gia_ManCiNum(p), Gia_ManCoNum(p), nBoxes, 3, 2 );
    pNew->pAigExtra = Gia_ManGenerateExtraAig( nBoxes, 3, 2 );
/*
    // normalize
    pNew = Gia_ManDupNormalize( pTemp = pNew, 0 );
    pNew->pManTime  = pTemp->pManTime;  pTemp->pManTime  = NULL;
    pNew->pAigExtra = pTemp->pAigExtra; pTemp->pAigExtra = NULL;
    Gia_ManStop( pTemp );
*/
    //pNew = Gia_ManDupCollapse( pTemp = pNew, pNew->pAigExtra, NULL );
    //Gia_ManStop( pTemp );
 
    //Gia_ManIllustrateBoxes( pNew );
    if ( fVerbose )
        Abc_PrintTime( 1, "AIG with boxes construction time", Abc_Clock() - clk );
    return pNew;
}

Here is the call graph for this function:

Gia_ManFindAnnotatedDelay()

int Gia_ManFindAnnotatedDelay	(	Gia_Man_t *	p,
		int	DelayC,
		int *	pnBoxes,
		int	fIgnoreBoxDelays )

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

Synopsis [Adds artificial carry chains to the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 1055 of file acecFadds.c.

{
    Gia_Obj_t * pObj;
    int nRealPis = Gia_ManBoxNum(p) ? Tim_ManPiNum((Tim_Man_t *)p->pManTime) : Gia_ManCiNum(p);
    int * pDelays = Vec_IntArray(p->vLevels);
    int i, k, iBox, iBoxOutId, Delay, Delay0, Delay1, DelayMax = 0, nBoxes = 0;
    Vec_IntFill( p->vLevels, Gia_ManObjNum(p), 0 );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
        {
            if ( fIgnoreBoxDelays )
                continue;
            // check if it is real PI
            iBoxOutId = Gia_ObjCioId(pObj) - nRealPis;
            if ( iBoxOutId < 0 )
                continue;
            // if it is a box output, find box number
            iBox = iBoxOutId / 2;
            assert( iBox < Gia_ManBoxNum(p) );
            // check find the maximum delay of the box inputs
            Delay = 0;
            for ( k = 0; k < 3; k++ )
            {
                int Id = Gia_ObjId( p, Gia_ManCo(p, iBox*3+k) );
                assert( Id < i );
                Delay = Abc_MaxInt( Delay, pDelays[Id] );
            }
            // consider outputs
            if ( iBoxOutId & 1 ) // carry output
                Delay += DelayC;
            else // sum output
                Delay += 100;
            pDelays[i] = Delay;
            continue;
        }
        if ( Gia_ObjIsCo(pObj) )
        {
            pDelays[i] = pDelays[Gia_ObjFaninId0(pObj, i)];
            DelayMax = Abc_MaxInt( DelayMax, pDelays[i] );
            continue;
        }
        assert( !pObj->fMark0 || !pObj->fMark1 );
        Delay0 = pDelays[Gia_ObjFaninId0(pObj, i)];
        Delay1 = pDelays[Gia_ObjFaninId1(pObj, i)];
        if ( pObj->fMark0 )
        {
            Delay = Abc_MaxInt( Delay0 + DelayC, Delay1 + 100 );
            nBoxes++;
        }
        else if ( pObj->fMark1 )
        {
            Delay = Abc_MaxInt( Delay1 + DelayC, Delay0 + 100 );
            nBoxes++;
        }
        else
            Delay = Abc_MaxInt( Delay0 + 100, Delay1 + 100 );
        pDelays[i] = Delay;
    }
    if ( pnBoxes )
        *pnBoxes = nBoxes;
    return DelayMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManFindChains()

void Gia_ManFindChains	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap )

Definition at line 520 of file acecFadds.c.

{
    int i;
    // for each FADD find the longest chain rooted in it
    Vec_Int_t * vLength = Vec_IntStartFull( Gia_ManObjNum(p) );
    Dtc_ForEachFadd( vFadds, i )
        Gia_ManFindChains_rec( p, Vec_IntEntry(vFadds, 5*i+4), vFadds, vMap, vLength );
    Vec_IntFree( vLength );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManFindChains_rec()

int Gia_ManFindChains_rec	(	Gia_Man_t *	p,
		int	iMaj,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap,
		Vec_Int_t *	vLength )

Definition at line 489 of file acecFadds.c.

{
    assert( Vec_IntEntry(vMap, iMaj) >= 0 ); // MAJ
    if ( Vec_IntEntry(vLength, iMaj) >= 0 )
        return Vec_IntEntry(vLength, iMaj);
    assert( Gia_ObjIsAnd(Gia_ManObj(p, iMaj)) );
    {
        int iFadd = Vec_IntEntry( vMap, iMaj );
        int iXor0 = Vec_IntEntry( vFadds, 5*iFadd+0 );
        int iXor1 = Vec_IntEntry( vFadds, 5*iFadd+1 );
        int iXor2 = Vec_IntEntry( vFadds, 5*iFadd+2 );
        int iLen0 = Vec_IntEntry( vMap, iXor0 ) == -1 ? 0 : Gia_ManFindChains_rec( p, iXor0, vFadds, vMap, vLength );
        int iLen1 = Vec_IntEntry( vMap, iXor1 ) == -1 ? 0 : Gia_ManFindChains_rec( p, iXor1, vFadds, vMap, vLength );
        int iLen2 = Vec_IntEntry( vMap, iXor2 ) == -1 ? 0 : Gia_ManFindChains_rec( p, iXor2, vFadds, vMap, vLength );
        int iLen = Abc_MaxInt( iLen0, Abc_MaxInt(iLen1, iLen2) );
        if ( iLen0 < iLen )
        {
            if ( iLen == iLen1 )
            {
                ABC_SWAP( int, Vec_IntArray(vFadds)[5*iFadd+0], Vec_IntArray(vFadds)[5*iFadd+1] );
            }
            else if ( iLen == iLen2 )
            {
                ABC_SWAP( int, Vec_IntArray(vFadds)[5*iFadd+0], Vec_IntArray(vFadds)[5*iFadd+2] );
            }
        }
        Vec_IntWriteEntry( vLength, iMaj, iLen + 1 );
        return iLen + 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManFindChainStart()

int Gia_ManFindChainStart

(

Gia_Man_t *

p

)

Definition at line 1124 of file acecFadds.c.

{
    Gia_Obj_t * pObj;
    int * pDelays = Vec_IntArray(p->vLevels);
    int i, iMax = -1, DelayMax = 0;
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( Gia_ObjIsUsed(pObj) )
            continue;
        if ( DelayMax > pDelays[i] )
            continue;
        DelayMax = pDelays[i];
        iMax = i;
    }
    return iMax;
}

Here is the caller graph for this function:

Gia_ManFindMapping()

Vec_Int_t * Gia_ManFindMapping	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap,
		Vec_Wec_t *	vChains )

Definition at line 620 of file acecFadds.c.

{
    Vec_Int_t * vChain;
    int i, k, iFadd = -1;
    Vec_Int_t * vMap2Chain = Vec_IntStartFull( Gia_ManObjNum(p) );
    Vec_WecForEachLevel( vChains, vChain, i )
    {
        assert( Vec_IntSize(vChain) > 0 );
        Vec_IntForEachEntry( vChain, iFadd, k )
        {
            //printf( "Chain %d: setting SUM %d (obj %d)\n", i, k, Vec_IntEntry(vFadds, 5*iFadd+3) );
            assert( Vec_IntEntry(vMap2Chain, Vec_IntEntry(vFadds, 5*iFadd+3)) == -1 );
            Vec_IntWriteEntry( vMap2Chain, Vec_IntEntry(vFadds, 5*iFadd+3), i );
        }
        //printf( "Chain %d: setting CARRY (obj %d)\n", i, Vec_IntEntry(vFadds, 5*iFadd+4) );
        assert( Vec_IntEntry(vMap2Chain, Vec_IntEntry(vFadds, 5*iFadd+4)) == -1 );
        Vec_IntWriteEntry( vMap2Chain, Vec_IntEntry(vFadds, 5*iFadd+4), i );
    }
    return vMap2Chain;
}

Here is the caller graph for this function:

Gia_ManFindPath()

int Gia_ManFindPath	(	Gia_Man_t *	p,
		int	DelayC,
		int	nPathMin,
		int	nPathMax,
		Vec_Int_t *	vPath )

Definition at line 1141 of file acecFadds.c.

{
    Gia_Obj_t * pObj, * pFanin0, * pFanin1;
    int * pDelays = Vec_IntArray(p->vLevels);
    int i, iLit, iMax = Gia_ManFindChainStart( p );
    if ( iMax == -1 )
        return -1;
    Vec_IntClear( vPath );
    pObj = Gia_ManObj(p, iMax);
    assert( Gia_ObjIsAnd(pObj) );
    while ( Gia_ObjIsAnd(pObj) )
    {
        assert( !Gia_ObjIsUsed(pObj) );
        pFanin0 = Gia_ObjFanin0(pObj);
        pFanin1 = Gia_ObjFanin1(pObj);
        if ( Gia_ObjIsUsed(pFanin0) && Gia_ObjIsUsed(pFanin1) )
            break;
        if ( Gia_ObjIsUsed(pFanin0) )
        {
            Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 1) );
            pObj = pFanin1;
        }
        else if ( Gia_ObjIsUsed(pFanin1) )
        {
            Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 0) );
            pObj = pFanin0;
        }
        else
        {
            if ( pDelays[Gia_ObjId(p, pFanin1)] > pDelays[Gia_ObjId(p, pFanin0)] )
            {
                Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 1) );
                pObj = pFanin1;
            }
            else
            {
                Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 0) );
                pObj = pFanin0;
            }
        }
    }
    if ( Vec_IntSize(vPath) < nPathMin )
    {
        Gia_ManObj(p, iMax)->fPhase = 1;
        return 0;
    }
    // label nodes
    if ( Vec_IntSize(vPath) > nPathMax )
        Vec_IntShrink( vPath, nPathMax );
    Vec_IntForEachEntry( vPath, iLit, i )
    {
        pObj = Gia_ManObj( p, Abc_Lit2Var(iLit) );
        if ( Abc_LitIsCompl(iLit) )
        {
            assert( pObj->fMark1 == 0 );
            pObj->fMark1 = 1;
            assert( Gia_ObjFanin1(pObj)->fPhase == 0 );
            Gia_ObjFanin1(pObj)->fPhase = 1;
        }
        else
        {
            assert( pObj->fMark0 == 0 );
            pObj->fMark0 = 1;
            assert( Gia_ObjFanin0(pObj)->fPhase == 0 );
            Gia_ObjFanin0(pObj)->fPhase = 1;
        }
    }
    return Vec_IntSize(vPath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManGenerateDelayTableFloat()

float * Gia_ManGenerateDelayTableFloat	(	int	nIns,
		int	nOuts )

Definition at line 670 of file acecFadds.c.

{
    int i, Total = nIns * nOuts;
    float * pDelayTable = ABC_ALLOC( float, Total + 3 );
    pDelayTable[0] = 0;
    pDelayTable[1] = nIns;
    pDelayTable[2] = nOuts;
    for ( i = 0; i < Total; i++ )
        pDelayTable[i+3] = 1;
    pDelayTable[i+3 - nIns] = -ABC_INFINITY;
    return pDelayTable;
}

Here is the caller graph for this function:

Gia_ManGenerateExtraAig()

Gia_Man_t * Gia_ManGenerateExtraAig	(	int	nBoxes,
		int	nIns,
		int	nOuts )

Definition at line 704 of file acecFadds.c.

{
    Gia_Man_t * pNew = Gia_ManStart( nBoxes * 20 );
    int i, k, pInLits[16], pOutLits[16];
    assert( nIns < 16 && nOuts < 16 );
    for ( i = 0; i < nIns; i++ )
        pInLits[i] = Gia_ManAppendCi( pNew );
    pOutLits[0] = Gia_ManAppendXor( pNew, Gia_ManAppendXor(pNew, pInLits[0], pInLits[1]), pInLits[2] );
    pOutLits[1] = Gia_ManAppendMaj( pNew, pInLits[0], pInLits[1], pInLits[2] );
    for ( i = 0; i < nBoxes; i++ )
        for ( k = 0; k < nOuts; k++ )
            Gia_ManAppendCo( pNew, pOutLits[k] );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManGenerateTim()

Tim_Man_t * Gia_ManGenerateTim	(	int	nPis,
		int	nPos,
		int	nBoxes,
		int	nIns,
		int	nOuts )

Definition at line 682 of file acecFadds.c.

{
    Tim_Man_t * pMan;
    int i, curPi, curPo;
    Vec_Ptr_t * vDelayTables = Vec_PtrAlloc( 1 );
    Vec_PtrPush( vDelayTables, Gia_ManGenerateDelayTableFloat(nIns, nOuts) );
    pMan = Tim_ManStart( nPis + nOuts * nBoxes, nPos + nIns * nBoxes );
    Tim_ManSetDelayTables( pMan, vDelayTables );
    curPi = nPis;
    curPo = 0;
    for ( i = 0; i < nBoxes; i++ )
    {
        Tim_ManCreateBox( pMan, curPo, nIns, curPi, nOuts, 0, 0 );
        curPi += nOuts;
        curPo += nIns;
    }
    curPo += nPos;
    assert( curPi == Tim_ManCiNum(pMan) );
    assert( curPo == Tim_ManCoNum(pMan) );
    //Tim_ManPrint( pMan );
    return pMan;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManIllustrateBoxes()

void Gia_ManIllustrateBoxes

(

Gia_Man_t *

p

)

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

Synopsis [Derive GIA with boxes containing adder-chains.]

Description []

SideEffects []

SeeAlso []

Definition at line 140 of file acecFadds.c.

{
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    int nBoxes = Tim_ManBoxNum( pManTime );
    int i, k, curCi, curCo, nBoxIns, nBoxOuts;
    Gia_Obj_t * pObj;
    // walk through the boxes
    curCi = Tim_ManPiNum(pManTime);
    curCo = 0;
    for ( i = 0; i < nBoxes; i++ )
    {
        nBoxIns = Tim_ManBoxInputNum(pManTime, i);
        nBoxOuts = Tim_ManBoxOutputNum(pManTime, i);
        printf( "Box %4d  [%d x %d] :   ", i, nBoxIns, nBoxOuts );
        printf( "Input obj IDs = " );
        for ( k = 0; k < nBoxIns; k++ )
        {
            pObj = Gia_ManCo( p, curCo + k );
            printf( "%d ", Gia_ObjId(p, pObj) );
        }
        printf( "  Output obj IDs = " );
        for ( k = 0; k < nBoxOuts; k++ )
        {
            pObj = Gia_ManCi( p, curCi + k );
            printf( "%d ", Gia_ObjId(p, pObj) );
        }
        curCo += nBoxIns;
        curCi += nBoxOuts;
        printf( "\n" );
    }
    curCo += Tim_ManPoNum(pManTime);
    // verify counts
    assert( curCi == Gia_ManCiNum(p) );
    assert( curCo == Gia_ManCoNum(p) );
}

Here is the call graph for this function:

Gia_ManIteratePaths()

int Gia_ManIteratePaths	(	Gia_Man_t *	p,
		int	DelayC,
		int	nPathMin,
		int	nPathMax,
		int	nPathLimit,
		int	fIgnoreBoxDelays,
		int	fVerbose )

Definition at line 1211 of file acecFadds.c.

{
    Gia_Obj_t * pObj;
    Vec_Int_t * vPath = Vec_IntAlloc( 100 );
    int i, RetValue, nBoxes, MaxDelay, nPaths = 0;
    assert( p->vLevels == NULL );
    p->vLevels = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_ManCleanMark01( p );
    Gia_ManCleanPhase( p );
    Gia_ManForEachCi( p, pObj, i )
        pObj->fPhase = 1;
    if ( fVerbose )
        printf( "Running path detection: BoxDelay = %d, PathMin = %d, PathMax = %d, PathLimit = %d.\n", DelayC, nPathMin, nPathMax, nPathLimit );
    for ( i = 0; i < nPathLimit; i++ )
    {
        MaxDelay = Gia_ManFindAnnotatedDelay( p, DelayC, &nBoxes, fIgnoreBoxDelays );
        RetValue = Gia_ManFindPath( p, DelayC, nPathMin, nPathMax, vPath );
        if ( RetValue == -1 )
            break;
        nPaths += (RetValue > 0);
        if ( fVerbose )
            printf( "Iter %5d : Paths = %2d. Boxes = %2d. Total boxes = %6d.  Max delay = %5d.\n", i, nPaths, RetValue, nBoxes, MaxDelay );
    }
    Vec_IntFree( vPath );
    Vec_IntFreeP( &p->vLevels );
    Gia_ManCleanPhase( p );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManMarkWithTravId_rec()

void Gia_ManMarkWithTravId_rec	(	Gia_Man_t *	p,
		int	Id )

Definition at line 543 of file acecFadds.c.

{
    Gia_Obj_t * pObj;
    if ( Gia_ObjIsTravIdCurrentId(p, Id) )
        return;
    Gia_ObjSetTravIdCurrentId(p, Id);
    pObj = Gia_ManObj( p, Id );
    if ( Gia_ObjIsAnd(pObj) )
        Gia_ManMarkWithTravId_rec( p, Gia_ObjFaninId0(pObj, Id) );
    if ( Gia_ObjIsAnd(pObj) )
        Gia_ManMarkWithTravId_rec( p, Gia_ObjFaninId1(pObj, Id) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManPrintChains()

void Gia_ManPrintChains	(	Gia_Man_t *	p,
		Vec_Int_t *	vFadds,
		Vec_Int_t *	vMap,
		Vec_Wec_t *	vChains )

Definition at line 590 of file acecFadds.c.

{
    Vec_Int_t * vChain;
    int i, k, iFadd, Count = 0;
    Vec_WecForEachLevel( vChains, vChain, i )
    {
        Count += Vec_IntSize(vChain);
        if ( i < 10 )
        {
            printf( "Chain %4d : %4d    ", i, Vec_IntSize(vChain) );
            Vec_IntForEachEntry( vChain, iFadd, k )
            {
                printf( "%d(%d) ", iFadd, Vec_IntEntry(vFadds, 5*iFadd+4) );
                if ( k != Vec_IntSize(vChain) - 1 )
                    printf( "-> " );
                if ( k > 6 )
                {
                    printf( "..." );
                    break;
                }
            }
            printf( "\n" );
        }
        else if ( i == 10 )
            printf( "...\n" );
 
    }
    printf( "Total chains = %d. Total full-adders = %d.\n", Vec_WecSize(vChains), Count );
}

Here is the caller graph for this function:

Gia_ObjFanin0CopyCarry()

int Gia_ObjFanin0CopyCarry	(	Vec_Int_t *	vCarries,
		Gia_Obj_t *	pObj,
		int	Id )

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

Synopsis [Converting AIG with annotated carry-chains into AIG with boxes.]

Description [Assumes that annotations are pObj->fMark0 or pObj->fMark1. Only one of these can be set to 1. If fMark0 (fMark1) is set to 1, the first (second) input of an AND-gate is chained.]

SideEffects []

SeeAlso []

Definition at line 909 of file acecFadds.c.

{
    if ( vCarries == NULL || Vec_IntEntry(vCarries, Gia_ObjFaninId0(pObj, Id)) == -1 )
        return Gia_ObjFanin0Copy(pObj);
    return Abc_LitNotCond( Vec_IntEntry(vCarries, Gia_ObjFaninId0(pObj, Id)), Gia_ObjFaninC0(pObj) );
}

Here is the caller graph for this function:

Gia_ObjFanin1CopyCarry()

int Gia_ObjFanin1CopyCarry	(	Vec_Int_t *	vCarries,
		Gia_Obj_t *	pObj,
		int	Id )

Definition at line 915 of file acecFadds.c.

{
    if ( vCarries == NULL || Vec_IntEntry(vCarries, Gia_ObjFaninId1(pObj, Id)) == -1 )
        return Gia_ObjFanin1Copy(pObj);
    return Abc_LitNotCond( Vec_IntEntry(vCarries, Gia_ObjFaninId1(pObj, Id)), Gia_ObjFaninC1(pObj) );
}

Here is the caller graph for this function: