mirror of https://github.com/YosysHQ/abc.git
Support of pair-wise miter and other changes.
This commit is contained in:
Alan Mishchenko
parent
3b4a4481a1
commit
625ccde611
|
|
@ -2964,6 +2964,44 @@ Vec_Ptr_t * Gia_ManMiterNames( Vec_Ptr_t * p, int nOuts )
|
|||
return pNew;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Pair-wise miter.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Gia_Man_t * Gia_ManPairWiseMiter( Gia_Man_t * p )
|
||||
{
|
||||
Gia_Man_t * pNew, * pTemp;
|
||||
Gia_Obj_t * pObj, * pObj2;
|
||||
int i, k, iLit;
|
||||
pNew = Gia_ManStart( Gia_ManObjNum(p) );
|
||||
pNew->pName = Abc_UtilStrsav( p->pName );
|
||||
pNew->pSpec = Abc_UtilStrsav( p->pSpec );
|
||||
Gia_ManConst0(p)->Value = 0;
|
||||
Gia_ManHashAlloc( pNew );
|
||||
Gia_ManForEachCi( p, pObj, i )
|
||||
pObj->Value = Gia_ManAppendCi( pNew );
|
||||
Gia_ManForEachAnd( p, pObj, i )
|
||||
pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
|
||||
Gia_ManForEachPo( p, pObj, i )
|
||||
Gia_ManForEachPo( p, pObj2, k )
|
||||
{
|
||||
if ( i >= k )
|
||||
continue;
|
||||
iLit = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(pObj2) );
|
||||
Gia_ManAppendCo( pNew, iLit );
|
||||
}
|
||||
pNew = Gia_ManCleanup( pTemp = pNew );
|
||||
Gia_ManStop( pTemp );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Transforms the circuit into a regular miter.]
|
||||
|
|
|
|||
|
|
@ -814,6 +814,328 @@ int Gia_ManHashDualMiter( Gia_Man_t * p, Vec_Int_t * vOuts )
|
|||
return iRes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Create multi-input tree.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int * Gia_ManCollectLiterals( int nVars )
|
||||
{
|
||||
int i, * pRes = ABC_CALLOC( int, nVars );
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
pRes[i] = Abc_Var2Lit( i+1, 0 );
|
||||
return pRes;
|
||||
}
|
||||
int * Gia_ManGenZero( int nBits )
|
||||
{
|
||||
return ABC_CALLOC( int, nBits );
|
||||
}
|
||||
int * Gia_ManGenPerm( int nBits )
|
||||
{
|
||||
int i, * pRes = ABC_CALLOC( int, nBits );
|
||||
srand( time(NULL) );
|
||||
for ( i = 0; i < nBits; i++ )
|
||||
pRes[i] = i;
|
||||
for ( i = 0; i < nBits; i++ )
|
||||
{
|
||||
int iPerm = rand() % nBits;
|
||||
ABC_SWAP( int, pRes[i], pRes[iPerm] );
|
||||
}
|
||||
return pRes;
|
||||
}
|
||||
int * Gia_ManGenPerm2( int nBits )
|
||||
{
|
||||
int i, * pRes = ABC_CALLOC( int, nBits );
|
||||
srand( time(NULL) );
|
||||
for ( i = 0; i < nBits; i++ )
|
||||
pRes[i] = rand() % nBits;
|
||||
return pRes;
|
||||
}
|
||||
int Gia_ManMultiCheck( int * pPerm, int nPerm )
|
||||
{
|
||||
int i;
|
||||
for ( i = 1; i < nPerm; i++ )
|
||||
if ( pPerm[i-1] <= pPerm[i] )
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
int Gia_ManMultiInputPerm( Gia_Man_t * pNew, int * pVars, int nVars, int * pPerm, int fOr, int fXor )
|
||||
{
|
||||
int fPrint = 1;
|
||||
int i, iLit;
|
||||
if ( fPrint )
|
||||
{
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
printf( "%d ", pPerm[i] );
|
||||
printf( "\n" );
|
||||
}
|
||||
while ( 1 )
|
||||
{
|
||||
for ( i = 1; i < nVars; i++ )
|
||||
if ( pPerm[i-1] >= pPerm[i] )
|
||||
break;
|
||||
if ( i == nVars )
|
||||
break;
|
||||
assert( pPerm[i-1] >= pPerm[i] );
|
||||
if ( pPerm[i-1] > pPerm[i] )
|
||||
{
|
||||
ABC_SWAP( int, pPerm[i-1], pPerm[i] );
|
||||
ABC_SWAP( int, pVars[i-1], pVars[i] );
|
||||
}
|
||||
else
|
||||
{
|
||||
assert( pPerm[i-1] == pPerm[i] );
|
||||
pPerm[i-1]++;
|
||||
if ( fXor )
|
||||
pVars[i-1] = Gia_ManHashXor( pNew, pVars[i-1], pVars[i] );
|
||||
else if ( fOr )
|
||||
pVars[i-1] = Gia_ManHashOr( pNew, pVars[i-1], pVars[i] );
|
||||
else
|
||||
pVars[i-1] = Gia_ManHashAnd( pNew, pVars[i-1], pVars[i] );
|
||||
for ( i = i+1; i < nVars; i++ )
|
||||
{
|
||||
pPerm[i-1] = pPerm[i];
|
||||
pVars[i-1] = pVars[i];
|
||||
}
|
||||
nVars--;
|
||||
}
|
||||
if ( fPrint )
|
||||
{
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
printf( "%d ", pPerm[i] );
|
||||
printf( "\n" );
|
||||
}
|
||||
}
|
||||
iLit = pVars[0];
|
||||
for ( i = 1; i < nVars; i++ )
|
||||
if ( fXor )
|
||||
iLit = Gia_ManHashXor( pNew, iLit, pVars[i] );
|
||||
else if ( fOr )
|
||||
iLit = Gia_ManHashOr( pNew, iLit, pVars[i] );
|
||||
else
|
||||
iLit = Gia_ManHashAnd( pNew, iLit, pVars[i] );
|
||||
return iLit;
|
||||
}
|
||||
Gia_Man_t * Gia_ManMultiInputTest( int nBits )
|
||||
{
|
||||
Gia_Man_t * pNew;
|
||||
int i, iRes, * pPerm;
|
||||
int * pMulti = Gia_ManCollectLiterals( nBits );
|
||||
pNew = Gia_ManStart( 1000 );
|
||||
pNew->pName = Abc_UtilStrsav( "multi" );
|
||||
for ( i = 0; i < nBits; i++ )
|
||||
Gia_ManAppendCi( pNew );
|
||||
Gia_ManHashAlloc( pNew );
|
||||
pPerm = Gia_ManGenPerm2( nBits );
|
||||
//pPerm = Gia_ManGenZero( nBits );
|
||||
iRes = Gia_ManMultiInputPerm( pNew, pMulti, nBits, pPerm, 0, 0 );
|
||||
Gia_ManAppendCo( pNew, iRes );
|
||||
ABC_FREE( pPerm );
|
||||
ABC_FREE( pMulti );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Create MUX tree.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Gia_ManCube( Gia_Man_t * pNew, int Vars, int nVars, int * pLits )
|
||||
{
|
||||
int i, iLit = 1;
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
iLit = Gia_ManHashAnd( pNew, iLit, Abc_LitNotCond(pLits[i], !((Vars >> i) & 1)) );
|
||||
return iLit;
|
||||
}
|
||||
int Gia_ManMuxTree_rec( Gia_Man_t * pNew, int * pCtrl, int nCtrl, int * pData )
|
||||
{
|
||||
int iLit0, iLit1;
|
||||
if ( nCtrl == 0 )
|
||||
return pData[0];
|
||||
iLit0 = Gia_ManMuxTree_rec( pNew, pCtrl, nCtrl-1, pData );
|
||||
iLit1 = Gia_ManMuxTree_rec( pNew, pCtrl, nCtrl-1, pData + (1<<(nCtrl-1)) );
|
||||
return Gia_ManHashMux( pNew, pCtrl[nCtrl-1], iLit1, iLit0 );
|
||||
}
|
||||
void Gia_ManUsePerm( int * pTree, int nBits, int * pPerm )
|
||||
{
|
||||
int fPrint = 0;
|
||||
int i, k, m, nVars = nBits + (1 << nBits);
|
||||
if ( fPrint )
|
||||
{
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
printf( "%d ", pPerm[i] );
|
||||
printf( "\n" );
|
||||
}
|
||||
for ( i = 0; i < nBits; i++ )
|
||||
{
|
||||
for ( k = i+1; k < nBits; k++ )
|
||||
if ( pPerm[i] > pPerm[k] )
|
||||
break;
|
||||
if ( k == nBits )
|
||||
break;
|
||||
assert( pPerm[i] > pPerm[k] );
|
||||
ABC_SWAP( int, pPerm[i], pPerm[k] );
|
||||
ABC_SWAP( int, pTree[i], pTree[k] );
|
||||
for ( m = 0; m < (1 << nBits); m++ )
|
||||
if ( ((m >> i) & 1) && !((m >> k) & 1) )
|
||||
{
|
||||
ABC_SWAP( int, pTree[nBits+m], pTree[nBits+(m^(1<<i)^(1<<k))] );
|
||||
ABC_SWAP( int, pPerm[nBits+m], pPerm[nBits+(m^(1<<i)^(1<<k))] );
|
||||
}
|
||||
}
|
||||
if ( fPrint )
|
||||
{
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
printf( "%d ", pPerm[i] );
|
||||
printf( "\n" );
|
||||
}
|
||||
}
|
||||
int Gia_ManFindCond( int * pLits, int nBits, int iLate1, int iLate2 )
|
||||
{
|
||||
int i;
|
||||
assert( iLate1 != iLate2 );
|
||||
for ( i = 0; i < nBits; i++ )
|
||||
if ( (((iLate1 ^ iLate2) >> i) & 1) )
|
||||
return Abc_LitNotCond( pLits[i], (iLate1 >> i) & 1 );
|
||||
return -1;
|
||||
}
|
||||
int Gia_ManLatest( int * pPerm, int nVars, int iPrev1, int iPrev2, int iPrev3 )
|
||||
{
|
||||
int i, Value = -1, iLate = -1;
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
if ( Value < pPerm[i] && i != iPrev1 && i != iPrev2 && i != iPrev3 )
|
||||
{
|
||||
Value = pPerm[i];
|
||||
iLate = i;
|
||||
}
|
||||
return iLate;
|
||||
}
|
||||
int Gia_ManEarliest( int * pPerm, int nVars )
|
||||
{
|
||||
int i, Value = ABC_INFINITY, iLate = -1;
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
if ( Value > pPerm[i] )
|
||||
{
|
||||
Value = pPerm[i];
|
||||
iLate = i;
|
||||
}
|
||||
return iLate;
|
||||
}
|
||||
int Gia_ManDecompOne( Gia_Man_t * pNew, int * pTree, int nBits, int * pPerm, int iLate )
|
||||
{
|
||||
int iRes, iData;
|
||||
assert( iLate >= 0 && iLate < (1<<nBits) );
|
||||
iData = pTree[nBits+iLate];
|
||||
pTree[nBits+iLate] = pTree[nBits+(iLate^1)];
|
||||
iRes = Gia_ManMuxTree_rec( pNew, pTree, nBits, pTree+nBits );
|
||||
return Gia_ManHashMux( pNew, Gia_ManCube(pNew, iLate, nBits, pTree), iData, iRes );
|
||||
}
|
||||
int Gia_ManDecompTwo( Gia_Man_t * pNew, int * pTree, int nBits, int * pPerm, int iLate1, int iLate2 )
|
||||
{
|
||||
int iRes, iData1, iData2, iData, iCond, iCond2;
|
||||
assert( iLate1 != iLate2 );
|
||||
assert( iLate1 >= 0 && iLate1 < (1<<nBits) );
|
||||
assert( iLate2 >= 0 && iLate2 < (1<<nBits) );
|
||||
iData1 = pTree[nBits+iLate1];
|
||||
iData2 = pTree[nBits+iLate2];
|
||||
pTree[nBits+iLate1] = pTree[nBits+(iLate1^1)];
|
||||
pTree[nBits+iLate2] = pTree[nBits+(iLate2^1)];
|
||||
iRes = Gia_ManMuxTree_rec( pNew, pTree, nBits, pTree+nBits );
|
||||
iCond = Gia_ManHashOr( pNew, Gia_ManCube(pNew, iLate1, nBits, pTree), Gia_ManCube(pNew, iLate2, nBits, pTree) );
|
||||
iCond2 = Gia_ManFindCond( pTree, nBits, iLate1, iLate2 );
|
||||
iData = Gia_ManHashMux( pNew, iCond2, iData2, iData1 );
|
||||
return Gia_ManHashMux( pNew, iCond, iData, iRes );
|
||||
}
|
||||
int Gia_ManDecompThree( Gia_Man_t * pNew, int * pTree, int nBits, int * pPerm, int iLate1, int iLate2, int iLate3 )
|
||||
{
|
||||
int iRes, iData1, iData2, iData3, iCube1, iCube2, iCube3, iCtrl0, iCtrl1, iMux10, iMux11;
|
||||
assert( iLate1 != iLate2 );
|
||||
assert( iLate1 != iLate3 );
|
||||
assert( iLate2 != iLate3 );
|
||||
assert( iLate1 >= 0 && iLate1 < (1<<nBits) );
|
||||
assert( iLate2 >= 0 && iLate2 < (1<<nBits) );
|
||||
assert( iLate3 >= 0 && iLate3 < (1<<nBits) );
|
||||
iData1 = pTree[nBits+iLate1];
|
||||
iData2 = pTree[nBits+iLate2];
|
||||
iData3 = pTree[nBits+iLate3];
|
||||
pTree[nBits+iLate1] = pTree[nBits+(iLate1^1)];
|
||||
pTree[nBits+iLate2] = pTree[nBits+(iLate2^1)];
|
||||
pTree[nBits+iLate3] = pTree[nBits+(iLate3^1)];
|
||||
iRes = Gia_ManMuxTree_rec( pNew, pTree, nBits, pTree+nBits );
|
||||
iCube1 = Gia_ManCube( pNew, iLate1, nBits, pTree );
|
||||
iCube2 = Gia_ManCube( pNew, iLate2, nBits, pTree );
|
||||
iCube3 = Gia_ManCube( pNew, iLate3, nBits, pTree );
|
||||
iCtrl0 = Gia_ManHashOr( pNew, iCube1, iCube3 );
|
||||
iCtrl1 = Gia_ManHashOr( pNew, iCube2, iCube3 );
|
||||
iMux10 = Gia_ManHashMux( pNew, iCtrl0, iData1, iRes );
|
||||
iMux11 = Gia_ManHashMux( pNew, iCtrl0, iData3, iData2 );
|
||||
return Gia_ManHashMux( pNew, iCtrl1, iMux11, iMux10 );
|
||||
}
|
||||
int Gia_ManDecomp( Gia_Man_t * pNew, int * pTree, int nBits, int * pPerm )
|
||||
{
|
||||
if ( nBits == 2 )
|
||||
return Gia_ManMuxTree_rec( pNew, pTree, nBits, pTree+nBits );
|
||||
else
|
||||
{
|
||||
int iBase = Gia_ManEarliest( pPerm+nBits, 1<<nBits ), BaseValue = pPerm[nBits+iBase];
|
||||
int iLate1 = Gia_ManLatest( pPerm+nBits, 1<<nBits, -1, -1, -1 );
|
||||
int iLate2 = Gia_ManLatest( pPerm+nBits, 1<<nBits, iLate1, -1, -1 );
|
||||
int iLate3 = Gia_ManLatest( pPerm+nBits, 1<<nBits, iLate1, iLate2, -1 );
|
||||
int iLate4 = Gia_ManLatest( pPerm+nBits, 1<<nBits, iLate1, iLate2, iLate3 );
|
||||
if ( 0 )
|
||||
{
|
||||
int i;
|
||||
for ( i = 0; i < (1<<nBits); i++ )
|
||||
printf( "%d ", pPerm[nBits+i] );
|
||||
printf( "\n" );
|
||||
}
|
||||
if ( pPerm[nBits+iLate1] > BaseValue && pPerm[nBits+iLate2] > BaseValue && pPerm[nBits+iLate3] > BaseValue && pPerm[nBits+iLate4] == BaseValue )
|
||||
return Gia_ManDecompThree( pNew, pTree, nBits, pPerm, iLate1, iLate2, iLate3 );
|
||||
if ( pPerm[nBits+iLate1] > BaseValue && pPerm[nBits+iLate2] > BaseValue && pPerm[nBits+iLate3] == BaseValue )
|
||||
return Gia_ManDecompTwo( pNew, pTree, nBits, pPerm, iLate1, iLate2 );
|
||||
if ( pPerm[nBits+iLate1] > BaseValue && pPerm[nBits+iLate2] == BaseValue )
|
||||
return Gia_ManDecompOne( pNew, pTree, nBits, pPerm, iLate1 );
|
||||
return Gia_ManMuxTree_rec( pNew, pTree, nBits, pTree+nBits );
|
||||
}
|
||||
}
|
||||
Gia_Man_t * Gia_ManMuxTreeTest( int nBits )
|
||||
{
|
||||
Gia_Man_t * pNew;
|
||||
int i, iLit, nVars = nBits + (1 << nBits);
|
||||
int * pPerm, * pTree = Gia_ManCollectLiterals( nVars );
|
||||
pNew = Gia_ManStart( 1000 );
|
||||
pNew->pName = Abc_UtilStrsav( "mux_tree" );
|
||||
for ( i = 0; i < nVars; i++ )
|
||||
Gia_ManAppendCi( pNew );
|
||||
Gia_ManHashAlloc( pNew );
|
||||
pPerm = Gia_ManGenPerm( nVars );
|
||||
//pPerm = Gia_ManGenZero( nVars );
|
||||
pPerm[nBits+1] = 100;
|
||||
pPerm[nBits+5] = 100;
|
||||
pPerm[nBits+4] = 100;
|
||||
Gia_ManUsePerm( pTree, nBits, pPerm );
|
||||
iLit = Gia_ManDecomp( pNew, pTree, nBits, pPerm );
|
||||
Gia_ManAppendCo( pNew, iLit );
|
||||
ABC_FREE( pPerm );
|
||||
ABC_FREE( pTree );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -1570,6 +1570,47 @@ void Gia_ManResubTest3_()
|
|||
Vec_PtrFree( vDivs );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Top level.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_ManResubPair( Vec_Wrd_t * vOn, Vec_Wrd_t * vOff, int nWords, int nIns )
|
||||
{
|
||||
Gia_ResbMan_t * p = Gia_ResbAlloc( nWords*2 );
|
||||
Vec_Ptr_t * vDivs = Vec_PtrAllocSimInfo( nIns+2, nWords*2 );
|
||||
word * pSim; int i;
|
||||
Vec_PtrForEachEntry( word *, vDivs, pSim, i )
|
||||
{
|
||||
if ( i == 0 )
|
||||
{
|
||||
memset( pSim, 0x00, sizeof(word)*nWords );
|
||||
memset( pSim+nWords, 0xFF, sizeof(word)*nWords );
|
||||
}
|
||||
else if ( i == 1 )
|
||||
{
|
||||
memset( pSim, 0xFF, sizeof(word)*nWords );
|
||||
memset( pSim+nWords, 0x00, sizeof(word)*nWords );
|
||||
}
|
||||
else
|
||||
{
|
||||
memmove( pSim, Vec_WrdEntryP(vOn, (i-2)*nWords), sizeof(word)*nWords );
|
||||
memmove( pSim+nWords, Vec_WrdEntryP(vOff, (i-2)*nWords), sizeof(word)*nWords );
|
||||
}
|
||||
}
|
||||
Gia_ManResubPerform( p, vDivs, nWords*2, 100, 0, 50, 1, 1, 0 );
|
||||
Gia_ManResubPrint( p->vGates, Vec_PtrSize(vDivs) );
|
||||
printf( "\n" );
|
||||
//Vec_PtrFree( vDivs );
|
||||
Gia_ResbFree( p );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Top level.]
|
||||
|
|
|
|||
|
|
@ -2923,6 +2923,166 @@ Gia_Man_t * Gia_ManConvertSupp( Gia_Man_t * p )
|
|||
return pNew;
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Transform flops.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Gia_Man_t * Gia_ManTransformCond2( Gia_Man_t * p )
|
||||
{
|
||||
int fOnly1 = 0;
|
||||
int fVerbose = 1;
|
||||
abctime clk = Abc_Clock();
|
||||
Gia_Man_t * pNew, * pTemp;
|
||||
Gia_Obj_t * pObjPi, * pObjRi, * pObjRo;
|
||||
int i, n, iTempLit, iLits[2];
|
||||
assert( Gia_ManRegNum(p) > 0 );
|
||||
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, pObjPi, i )
|
||||
pObjPi->Value = Gia_ManAppendCi( pNew );
|
||||
Gia_ManHashAlloc( pNew );
|
||||
Gia_ManForEachRi( p, pObjRi, i )
|
||||
{
|
||||
//if ( (i - Gia_ManPoNum(p)) % 8 != 0 )
|
||||
// continue;
|
||||
pObjRo = Gia_ObjRiToRo(p, pObjRi);
|
||||
iTempLit = pObjRo->Value;
|
||||
for ( n = 0; n < 2; n++ )
|
||||
{
|
||||
pObjRo->Value = n;
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManConvertSupp_rec( pNew, p, Gia_ObjFanin0(pObjRi) );
|
||||
iLits[n] = Gia_ObjFanin0Copy(pObjRi);
|
||||
}
|
||||
pObjRo->Value = iTempLit;
|
||||
Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ManHashAnd( pNew, iLits[1], Abc_LitNot(iLits[0]) )) );
|
||||
Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ManHashAnd( pNew, iLits[0], Abc_LitNot(iLits[1]) )) );
|
||||
}
|
||||
Gia_ManHashStop( pNew );
|
||||
//Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
|
||||
pNew = Gia_ManCleanup( pTemp = pNew );
|
||||
Gia_ManStop( pTemp );
|
||||
if ( fVerbose )
|
||||
printf( "Created %d outputs. ", Gia_ManPoNum(pNew) );
|
||||
if ( fVerbose )
|
||||
Abc_PrintTime( 0, "Time", Abc_Clock() - clk );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Transform flops.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Vec_Wrd_t * Gia_ManDetectSims( Gia_Man_t * p, int iCo, int nWords )
|
||||
{
|
||||
extern int Cec4_ManGeneratePatterns_rec( Gia_Man_t * p, Gia_Obj_t * pObj, int Value, Vec_Int_t * vPat, Vec_Int_t * vVisit );
|
||||
Vec_Wrd_t * vSim = Vec_WrdStart( nWords * Gia_ManCiNum(p) );
|
||||
Vec_Int_t * vPat = Vec_IntAlloc( Gia_ManCiNum(p) );
|
||||
Vec_Int_t * vVis = Vec_IntAlloc( Gia_ManAndNum(p) );
|
||||
Gia_Obj_t * pObj = Gia_ManCo( p, iCo ), * pTemp; int iLit, i, k, nTries = 0;
|
||||
if ( Gia_ObjFanin0(pObj) == Gia_ManConst0(p) )
|
||||
return NULL;
|
||||
Gia_ManForEachObj( p, pTemp, k )
|
||||
assert( !pTemp->fMark0 && !pTemp->fMark1 );
|
||||
for ( i = 0; i < 64*nWords; )
|
||||
{
|
||||
int Res = Cec4_ManGeneratePatterns_rec( p, Gia_ObjFanin0(pObj), !Gia_ObjFaninC0(pObj), vPat, vVis );
|
||||
if ( Res )
|
||||
{
|
||||
Vec_IntForEachEntry( vPat, iLit, k )
|
||||
{
|
||||
if ( Abc_LitIsCompl(iLit) )
|
||||
continue;
|
||||
pTemp = Gia_ManObj( p, Abc_Lit2Var(iLit) );
|
||||
assert( Gia_ObjIsCi(pTemp) );
|
||||
Abc_InfoSetBit( (unsigned *)Vec_WrdEntryP(vSim, nWords*Gia_ObjCioId(pTemp)), i );
|
||||
}
|
||||
i++;
|
||||
}
|
||||
Gia_ManForEachObjVec( vVis, p, pTemp, k )
|
||||
pTemp->fMark0 = pTemp->fMark1 = 0;
|
||||
nTries++;
|
||||
}
|
||||
//printf( "%d ", nTries );
|
||||
Vec_IntFree( vPat );
|
||||
Vec_IntFree( vVis );
|
||||
return vSim;
|
||||
}
|
||||
Vec_Wrd_t * Vec_WrdInterleave( Vec_Wrd_t * p1, Vec_Wrd_t * p2, int nWords, int nIns )
|
||||
{
|
||||
Vec_Wrd_t * p = Vec_WrdAlloc( Vec_WrdSize(p1)+Vec_WrdSize(p2) );
|
||||
int i, k;
|
||||
assert( Vec_WrdSize(p1) == nWords*nIns );
|
||||
assert( Vec_WrdSize(p2) == nWords*nIns );
|
||||
for ( i = 0; i < nIns; i++ )
|
||||
{
|
||||
for ( k = 0; k < nWords; k++ )
|
||||
Vec_WrdPush( p, Vec_WrdEntry(p1, i*nWords+k) );
|
||||
for ( k = 0; k < nWords; k++ )
|
||||
Vec_WrdPush( p, Vec_WrdEntry(p2, i*nWords+k) );
|
||||
}
|
||||
return p;
|
||||
}
|
||||
Gia_Man_t * Gia_ManTransformCond( Gia_Man_t * p )
|
||||
{
|
||||
extern void Gia_ManResubPair( Vec_Wrd_t * vOn, Vec_Wrd_t * vOff, int nWords, int nIns );
|
||||
abctime clk = Abc_Clock();
|
||||
Vec_Wrd_t * vSims;
|
||||
Vec_Wrd_t * vSim[4];
|
||||
Vec_Wrd_t * vInt[6];
|
||||
int i;
|
||||
for ( i = 0; i < Gia_ManCoNum(p); i++ )
|
||||
{
|
||||
vSims = Gia_ManDetectSims( p, i, 1 );
|
||||
if ( i >= Gia_ManCoNum(p)-4 )
|
||||
vSim[i-(Gia_ManCoNum(p)-4)] = vSims;
|
||||
else
|
||||
Vec_WrdFreeP( &vSims );
|
||||
//Vec_PtrPush( vAll, vSims );
|
||||
}
|
||||
vInt[0] = Vec_WrdInterleave( vSim[0], vSim[1], 1, Gia_ManCiNum(p) );
|
||||
vInt[1] = Vec_WrdInterleave( vSim[0], vSim[2], 1, Gia_ManCiNum(p) );
|
||||
vInt[2] = Vec_WrdInterleave( vSim[0], vSim[3], 1, Gia_ManCiNum(p) );
|
||||
vInt[3] = Vec_WrdInterleave( vSim[1], vSim[2], 1, Gia_ManCiNum(p) );
|
||||
vInt[4] = Vec_WrdInterleave( vSim[1], vSim[3], 1, Gia_ManCiNum(p) );
|
||||
vInt[5] = Vec_WrdInterleave( vSim[2], vSim[3], 1, Gia_ManCiNum(p) );
|
||||
|
||||
Gia_ManResubPair( vInt[0], vInt[5], 2, Gia_ManCiNum(p) );
|
||||
Gia_ManResubPair( vInt[1], vInt[4], 2, Gia_ManCiNum(p) );
|
||||
Gia_ManResubPair( vInt[2], vInt[3], 2, Gia_ManCiNum(p) );
|
||||
|
||||
Gia_ManResubPair( vInt[5], vInt[0], 2, Gia_ManCiNum(p) );
|
||||
Gia_ManResubPair( vInt[4], vInt[1], 2, Gia_ManCiNum(p) );
|
||||
Gia_ManResubPair( vInt[3], vInt[2], 2, Gia_ManCiNum(p) );
|
||||
|
||||
/*
|
||||
for ( i = 0; i < 4; i++ )
|
||||
for ( k = i+1; k < 4; k++ )
|
||||
Gia_ManResubPair( vSim[i], vSim[k], 1, Gia_ManCiNum(p) );
|
||||
*/
|
||||
Abc_PrintTime( 0, "Time", Abc_Clock() - clk );
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -897,9 +897,9 @@ Vec_Ptr_t * Abc_NtkNodeSupport( Abc_Ntk_t * pNtk, Abc_Obj_t ** ppNodes, int nNod
|
|||
vNodes = Vec_PtrAlloc( 100 );
|
||||
// go through the PO nodes and call for each of them
|
||||
for ( i = 0; i < nNodes; i++ )
|
||||
if ( Abc_ObjIsCo(ppNodes[i]) )
|
||||
if ( Abc_ObjIsCo(ppNodes[i]) && Abc_ObjFaninNum(Abc_ObjFanin0(ppNodes[i])) != 0 )
|
||||
Abc_NtkNodeSupport_rec( Abc_ObjFanin0(ppNodes[i]), vNodes );
|
||||
else
|
||||
else if ( !Abc_ObjIsCo(ppNodes[i]) && Abc_ObjFaninNum(ppNodes[i]) != 0 )
|
||||
Abc_NtkNodeSupport_rec( ppNodes[i], vNodes );
|
||||
return vNodes;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36013,6 +36013,7 @@ usage:
|
|||
***********************************************************************/
|
||||
int Abc_CommandAbc9Miter( Abc_Frame_t * pAbc, int argc, char ** argv )
|
||||
{
|
||||
extern Gia_Man_t * Gia_ManPairWiseMiter( Gia_Man_t * p );
|
||||
FILE * pFile;
|
||||
Gia_Man_t * pAux;
|
||||
Gia_Man_t * pSecond;
|
||||
|
|
@ -36023,13 +36024,14 @@ int Abc_CommandAbc9Miter( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
int nInsDup = 0;
|
||||
int fDualOut = 0;
|
||||
int fSeq = 0;
|
||||
int fPairWise= 0;
|
||||
int fTrans = 0;
|
||||
int fTransX = 0;
|
||||
int fConvert = 0;
|
||||
int fTransZ = 0;
|
||||
int fVerbose = 0;
|
||||
Extra_UtilGetoptReset();
|
||||
while ( ( c = Extra_UtilGetopt( argc, argv, "Idstxyzvh" ) ) != EOF )
|
||||
while ( ( c = Extra_UtilGetopt( argc, argv, "Idsptxyzvh" ) ) != EOF )
|
||||
{
|
||||
switch ( c )
|
||||
{
|
||||
|
|
@ -36050,6 +36052,9 @@ int Abc_CommandAbc9Miter( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
case 's':
|
||||
fSeq ^= 1;
|
||||
break;
|
||||
case 'p':
|
||||
fPairWise ^= 1;
|
||||
break;
|
||||
case 't':
|
||||
fTrans ^= 1;
|
||||
break;
|
||||
|
|
@ -36071,6 +36076,17 @@ int Abc_CommandAbc9Miter( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
goto usage;
|
||||
}
|
||||
}
|
||||
if ( fPairWise )
|
||||
{
|
||||
if ( pAbc->pGia == NULL )
|
||||
{
|
||||
Abc_Print( -1, "Abc_CommandAbc9Miter(): There is no AIG.\n" );
|
||||
return 1;
|
||||
}
|
||||
pAux = Gia_ManPairWiseMiter( pAbc->pGia );
|
||||
Abc_FrameUpdateGia( pAbc, pAux );
|
||||
return 0;
|
||||
}
|
||||
if ( fTrans || fTransX || fTransZ || fConvert )
|
||||
{
|
||||
if ( pAbc->pGia == NULL )
|
||||
|
|
@ -36144,11 +36160,12 @@ int Abc_CommandAbc9Miter( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
return 0;
|
||||
|
||||
usage:
|
||||
Abc_Print( -2, "usage: &miter [-I num] [-dstxyzvh] <file>\n" );
|
||||
Abc_Print( -2, "usage: &miter [-I num] [-dsptxyzvh] <file>\n" );
|
||||
Abc_Print( -2, "\t creates miter of two designs (current AIG vs. <file>)\n" );
|
||||
Abc_Print( -2, "\t-I num : the number of last PIs to replicate [default = %d]\n", nInsDup );
|
||||
Abc_Print( -2, "\t-d : toggle creating dual-output miter [default = %s]\n", fDualOut? "yes": "no" );
|
||||
Abc_Print( -2, "\t-s : toggle creating sequential miter [default = %s]\n", fSeq? "yes": "no" );
|
||||
Abc_Print( -2, "\t-p : toggle creating pair-wise miter [default = %s]\n", fPairWise? "yes": "no" );
|
||||
Abc_Print( -2, "\t-t : toggle XORing POs of dual-output miter [default = %s]\n", fTrans? "yes": "no" );
|
||||
Abc_Print( -2, "\t-x : toggle XORing POs of two-word miter [default = %s]\n", fTransX? "yes": "no" );
|
||||
Abc_Print( -2, "\t-y : toggle convering two-word miter into dual-output miter [default = %s]\n", fConvert? "yes": "no" );
|
||||
|
|
|
|||
Loading…
Reference in New Issue