/**CFile****************************************************************
FileName [giaFadds.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Scalable AIG package.]
Synopsis [Extraction of full-adders.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - June 20, 2005.]
Revision [$Id: giaFadds.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
***********************************************************************/
#include "gia.h"
#include "misc/vec/vecWec.h"
#include "misc/tim/tim.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
#define Dtc_ForEachCut( pList, pCut, i ) for ( i = 0, pCut = pList + 1; i < pList[0]; i++, pCut += pCut[0] + 1 )
#define Dtc_ForEachFadd( vFadds, i ) for ( i = 0; i < Vec_IntSize(vFadds)/5; i++ )
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Derive GIA with boxes containing adder-chains.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManIllustrateBoxes( Gia_Man_t * p )
{
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) );
}
/**Function*************************************************************
Synopsis [Detecting FADDs in the AIG.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Dtc_ManCutMergeOne( int * pCut0, int * pCut1, int * pCut )
{
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;
}
int Dtc_ManCutCheckEqual( Vec_Int_t * vCuts, int * pCutNew )
{
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;
}
int Dtc_ObjComputeTruth_rec( Gia_Obj_t * pObj )
{
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) );
return (pObj->Value = (Gia_ObjFaninC0(pObj) ? ~Truth0 : Truth0) & (Gia_ObjFaninC1(pObj) ? ~Truth1 : Truth1));
}
void Dtc_ObjCleanTruth_rec( Gia_Obj_t * pObj )
{
if ( !pObj->Value )
return;
pObj->Value = 0;
if ( !Gia_ObjIsAnd(pObj) )
return;
Dtc_ObjCleanTruth_rec( Gia_ObjFanin0(pObj) );
Dtc_ObjCleanTruth_rec( Gia_ObjFanin1(pObj) );
}
int Dtc_ObjComputeTruth( Gia_Man_t * p, int iObj, int * pCut, int * pTruth )
{
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 == 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;
}
void Dtc_ManCutMerge( Gia_Man_t * p, int iObj, int * pList0, int * pList1, Vec_Int_t * vCuts, Vec_Int_t * vCutsXor, Vec_Int_t * vCutsMaj )
{
Vec_Int_t * vTemp;
int i, k, c, Type, * pCut0, * pCut1, pCut[4];
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 );
for ( c = 0; c <= pCut[0]; c++ )
Vec_IntPush( vCuts, pCut[c] );
if ( pCut[0] != 3 )
continue;
Type = Dtc_ObjComputeTruth( p, iObj, pCut, NULL );
if ( Type == 0 )
continue;
vTemp = Type == 1 ? vCutsXor : vCutsMaj;
for ( c = 1; c <= pCut[0]; c++ )
Vec_IntPush( vTemp, pCut[c] );
Vec_IntPush( vTemp, iObj );
}
}
void Dtc_ManComputeCuts( Gia_Man_t * p, Vec_Int_t ** pvCutsXor, Vec_Int_t ** pvCutsMaj, int fVerbose )
{
Gia_Obj_t * pObj;
int * pList0, * pList1, i, nCuts = 0;
Vec_Int_t * vTemp = Vec_IntAlloc( 1000 );
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, 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 );
*pvCutsXor = vCutsXor;
*pvCutsMaj = vCutsMaj;
}
Vec_Int_t * Dtc_ManFindCommonCuts( Gia_Man_t * p, Vec_Int_t * vCutsXor, Vec_Int_t * vCutsMaj )
{
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;
}
void Dtc_ManPrintFadds( Vec_Int_t * vFadds )
{
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" );
}
}
int Dtc_ManCompare( int * pCut0, int * pCut1 )
{
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;
}
int Dtc_ManCompare2( int * pCut0, int * pCut1 )
{
if ( pCut0[4] < pCut1[4] ) return -1;
if ( pCut0[4] > pCut1[4] ) return 1;
return 0;
}
// returns array of 5-tuples containing inputs/sum/cout of each full adder
Vec_Int_t * Gia_ManDetectFullAdders( Gia_Man_t * p, int fVerbose )
{
Vec_Int_t * vCutsXor, * vCutsMaj, * vFadds;
Dtc_ManComputeCuts( p, &vCutsXor, &vCutsMaj, fVerbose );
qsort( Vec_IntArray(vCutsXor), Vec_IntSize(vCutsXor)/4, 16, (int (*)(const void *, const void *))Dtc_ManCompare );
qsort( Vec_IntArray(vCutsMaj), Vec_IntSize(vCutsMaj)/4, 16, (int (*)(const void *, const void *))Dtc_ManCompare );
vFadds = Dtc_ManFindCommonCuts( p, vCutsXor, vCutsMaj );
qsort( Vec_IntArray(vFadds), 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 );
//Dtc_ManPrintFadds( vFadds );
Vec_IntFree( vCutsXor );
Vec_IntFree( vCutsMaj );
return vFadds;
}
/**Function*************************************************************
Synopsis [Map each MAJ into the topmost MAJ of its chain.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
// maps MAJ nodes into FADD indexes
Vec_Int_t * Gia_ManCreateMap( Gia_Man_t * p, Vec_Int_t * vFadds )
{
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;
}
// find chain length (for each MAJ, how many FADDs are rooted in its first input)
int Gia_ManFindChains_rec( Gia_Man_t * p, int iMaj, Vec_Int_t * vFadds, Vec_Int_t * vMap, Vec_Int_t * vLength )
{
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;
}
}
// for each FADD find the longest chain and reorder its inputs
void Gia_ManFindChains( Gia_Man_t * p, Vec_Int_t * vFadds, Vec_Int_t * vMap )
{
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 );
}
// collect one carry-chain
void Gia_ManCollectOneChain( Gia_Man_t * p, Vec_Int_t * vFadds, int iFaddTop, Vec_Int_t * vMap, Vec_Int_t * vChain )
{
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 );
}
void Gia_ManMarkWithTravId_rec( Gia_Man_t * p, int Id )
{
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) );
}
// returns mapping of each MAJ into the topmost elements of its chain
Vec_Wec_t * Gia_ManCollectTopmost( Gia_Man_t * p, Vec_Int_t * vFadds, Vec_Int_t * vMap, int nFaddMin )
{
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;
}
// prints chains beginning in majority nodes contained in vTops
void Gia_ManPrintChains( Gia_Man_t * p, Vec_Int_t * vFadds, Vec_Int_t * vMap, Vec_Wec_t * vChains )
{
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 );
}
// map SUM bits and topmost MAJ into topmost FADD number
Vec_Int_t * Gia_ManFindMapping( Gia_Man_t * p, Vec_Int_t * vFadds, Vec_Int_t * vMap, Vec_Wec_t * vChains )
{
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;
}
/**Function*************************************************************
Synopsis [Derive GIA with boxes containing adder-chains.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Int_t * Gia_ManCollectTruthTables( Gia_Man_t * p, Vec_Int_t * vFadds )
{
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;
}
float * Gia_ManGenerateDelayTableFloat( int nIns, int nOuts )
{
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;
}
Tim_Man_t * Gia_ManGenerateTim( int nPis, int nPos, int nBoxes, int nIns, int nOuts )
{
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 );
curPi += nOuts;
curPo += nIns;
}
curPo += nPos;
assert( curPi == Tim_ManCiNum(pMan) );
assert( curPo == Tim_ManCoNum(pMan) );
//Tim_ManPrint( pMan );
return pMan;
}
Gia_Man_t * Gia_ManGenerateExtraAig( int nBoxes, int nIns, int nOuts )
{
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;
}
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 )
{
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, 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;
}
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 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) );
}
Gia_Man_t * Gia_ManDupWithNaturalBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose )
{
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 );
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 coverted 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 );
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;
}
/**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 []
***********************************************************************/
int Gia_ObjFanin0CopyCarry( Vec_Int_t * vCarries, Gia_Obj_t * pObj, int Id )
{
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) );
}
int Gia_ObjFanin1CopyCarry( Vec_Int_t * vCarries, Gia_Obj_t * pObj, int Id )
{
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) );
}
Gia_Man_t * Gia_ManDupWithArtificalFaddBoxes( Gia_Man_t * p, int fUseFanout, int fXorTrick )
{
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;
}
Gia_Man_t * Gia_ManDupWithArtificalFaddBoxesTest( Gia_Man_t * p )
{
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;
}
/**Function*************************************************************
Synopsis [Adds artificial carry chains to the manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
// computes AIG delay information when boxes are used
int Gia_ManFindAnnotatedDelay( Gia_Man_t * p, int DelayC, int * pnBoxes, int fIgnoreBoxDelays )
{
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;
}
// check if the object is already used in some chain
static inline int Gia_ObjIsUsed( Gia_Obj_t * pObj )
{
return pObj->fMark0 || pObj->fMark1 || pObj->fPhase;
}
// finds internal node that can begin a new chain
int Gia_ManFindChainStart( Gia_Man_t * p )
{
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;
}
// finds a sequence of internal nodes that creates a new chain
int Gia_ManFindPath( Gia_Man_t * p, int DelayC, int nPathMin, int nPathMax, Vec_Int_t * vPath )
{
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);
}
// iteratively create the given number of chains
int Gia_ManIteratePaths( Gia_Man_t * p, int DelayC, int nPathMin, int nPathMax, int nPathLimit, int fIgnoreBoxDelays, int fVerbose )
{
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;
}
// annotate artificial chains and then put them into boxes
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 )
{
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;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END