abc-master: if.h File Reference

unsigned nLeaves

Definition: if.h:289

Abc_Lit2LitL

static int Abc_Lit2LitL(int *pMap, int Lit)

Definition: abc_global.h:270

If_CutTruthLit

static int If_CutTruthLit(If_Cut_t *pCut)

Definition: if.h:417

If_Man_t_::vTtDsds

Vec_Int_t * vTtDsds[IF_MAX_FUNC_LUTSIZE+1]

Definition: if.h:246

static char* If_CutDsdPerm	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 426 of file if.h.

426 { return Vec_StrEntryP( p->vTtPerms[pCut->nLeaves], Abc_Lit2Var(pCut->iCutFunc) * Abc_MaxInt(6, pCut->nLeaves) ); }

unsigned nLeaves

Definition: if.h:289

If_Man_t_::vTtPerms

Vec_Str_t * vTtPerms[IF_MAX_FUNC_LUTSIZE+1]

Definition: if.h:247

Abc_MaxInt

static int Abc_MaxInt(int a, int b)

Definition: abc_global.h:238

Abc_Lit2Var

static int Abc_Lit2Var(int Lit)

Definition: abc_global.h:264

int iCutFunc

Definition: if.h:281

Vec_StrEntryP

static char * Vec_StrEntryP(Vec_Str_t *p, int i)

Definition: vecStr.h:353

float If_CutEdgeDeref	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Computes area of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1133 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     float Edge;
     int i;
     Edge = pCut->nLeaves;
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         assert( pLeaf->nRefs > 0 );
         if ( --pLeaf->nRefs > 0 || !If_ObjIsAnd(pLeaf) )
             continue;
         Edge += If_CutEdgeDeref( p, If_ObjCutBest(pLeaf) );
     }
     return Edge;
 }

float If_CutEdgeDerefed	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Computes edge of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1187 of file ifCut.c.

 {
     float aResult, aResult2;
     if ( pCut->nLeaves < 2 )
         return pCut->nLeaves;
     aResult2 = If_CutEdgeRef( p, pCut );
     aResult  = If_CutEdgeDeref( p, pCut );
     assert( aResult > aResult2 - p->fEpsilon );
     assert( aResult < aResult2 + p->fEpsilon );
     return aResult;
 }

float If_CutEdgeFlow	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Computes area flow.]

Description []

SideEffects []

SeeAlso []

Definition at line 949 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     float Flow;
     int i;
     Flow = pCut->nLeaves;
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         if ( pLeaf->nRefs == 0 || If_ObjIsConst1(pLeaf) )
             Flow += If_ObjCutBest(pLeaf)->Edge;
         else 
         {
             assert( pLeaf->EstRefs > p->fEpsilon );
             Flow += If_ObjCutBest(pLeaf)->Edge / pLeaf->EstRefs;
         }
     }
     return Flow;
 }

float If_CutEdgeRef	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Computes area of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1160 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     float Edge;
     int i;
     Edge = pCut->nLeaves;
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         assert( pLeaf->nRefs >= 0 );
         if ( pLeaf->nRefs++ > 0 || !If_ObjIsAnd(pLeaf) )
             continue;
         Edge += If_CutEdgeRef( p, If_ObjCutBest(pLeaf) );
     }
     return Edge;
 }

float If_CutEdgeRefed	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Computes area of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1210 of file ifCut.c.

 {
     float aResult, aResult2;
     if ( pCut->nLeaves < 2 )
         return pCut->nLeaves;
     aResult2 = If_CutEdgeDeref( p, pCut );
     aResult  = If_CutEdgeRef( p, pCut );
     assert( aResult > aResult2 - p->fEpsilon );
     assert( aResult < aResult2 + p->fEpsilon );
     return aResult;
 }

int If_CutFilter	(	If_Set_t *	pCutSet,
		If_Cut_t *	pCut,
		int	fSaveCut0
	)

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

Synopsis [Returns 1 if the cut is contained.]

Description []

SideEffects []

SeeAlso []

Definition at line 146 of file ifCut.c.

 { 
     If_Cut_t * pTemp;
     int i, k;
     assert( pCutSet->ppCuts[pCutSet->nCuts] == pCut );
     for ( i = 0; i < pCutSet->nCuts; i++ )
     {
         pTemp = pCutSet->ppCuts[i];
         if ( pTemp->nLeaves > pCut->nLeaves )
         {
             // do not fiter the first cut
             if ( i == 0 && ((pCutSet->nCuts > 1 && pCutSet->ppCuts[1]->fUseless) || (fSaveCut0 && pCutSet->nCuts == 1)) )
                 continue;
             // skip the non-contained cuts
             if ( (pTemp->uSign & pCut->uSign) != pCut->uSign )
                 continue;
             // check containment seriously
             if ( If_CutCheckDominance( pCut, pTemp ) )
             {
 //                p->ppCuts[i] = p->ppCuts[p->nCuts-1];
 //                p->ppCuts[p->nCuts-1] = pTemp;
 //                p->nCuts--;
 //                i--;
                 // remove contained cut
                 for ( k = i; k < pCutSet->nCuts; k++ )
                     pCutSet->ppCuts[k] = pCutSet->ppCuts[k+1];
                 pCutSet->ppCuts[pCutSet->nCuts] = pTemp;
                 pCutSet->nCuts--;
                 i--;
             }
          }
         else
         {
             // skip the non-contained cuts
             if ( (pTemp->uSign & pCut->uSign) != pTemp->uSign )
                 continue;
             // check containment seriously
             if ( If_CutCheckDominance( pTemp, pCut ) )
                 return 1;
         }
     }
     return 0;
 }

static If_Obj_t* If_CutLeaf	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		int	i
	)

inlinestatic

Definition at line 392 of file if.h.

392 { assert(i >= 0 && i < (int)pCut->nLeaves); return If_ManObj(p, pCut->pLeaves[i]); }

unsigned nLeaves

Definition: if.h:289

If_ManObj

static If_Obj_t * If_ManObj(If_Man_t *p, int i)

Definition: if.h:370

int pLeaves[0]

Definition: if.h:290

#define assert(ex)

Definition: util_old.h:213

static int If_CutLeafBit	(	If_Cut_t *	pCut,
		int	i
	)

inlinestatic

Definition at line 396 of file if.h.

396 { return (pCut->uMaskFunc >> i) & 1; }

If_Cut_t_::uMaskFunc

int uMaskFunc

Definition: if.h:282

static int If_CutLeaveNum ( If_Cut_t * pCut )

inlinestatic

Definition at line 390 of file if.h.

390 { return pCut->nLeaves; }

unsigned nLeaves

Definition: if.h:289

static int* If_CutLeaves ( If_Cut_t * pCut )

inlinestatic

Definition at line 391 of file if.h.

391 { return pCut->pLeaves; }

int pLeaves[0]

Definition: if.h:290

void If_CutLift ( If_Cut_t * pCut )

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

Synopsis [Moves the cut over the latch.]

Description []

SideEffects []

SeeAlso []

Definition at line 897 of file ifCut.c.

 {
     unsigned i;
     for ( i = 0; i < pCut->nLeaves; i++ )
     {
         assert( (pCut->pLeaves[i] & 255) < 255 );
         pCut->pLeaves[i]++;
     }
 }

static float If_CutLutArea	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 428 of file if.h.

428 { return pCut->fUser? (float)pCut->Cost : (p->pPars->pLutLib? p->pPars->pLutLib->pLutAreas[pCut->nLeaves] : (float)1.0); }

unsigned nLeaves

Definition: if.h:289

If_Cut_t_::fUser

unsigned fUser

Definition: if.h:286

If_Cut_t_::Cost

unsigned Cost

Definition: if.h:284

If_LibLut_t_::fVarPinDelays

If_Par_t * pPars

Definition: if.h:184

If_LibLut_t_::pLutAreas

float pLutAreas[IF_MAX_LUTSIZE+1]

Definition: if.h:175

If_Par_t_::pLutLib

If_LibLut_t * pLutLib

Definition: if.h:160

int If_CutLutBalanceEval	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Evaluate delay using SOP balancing.]

Description []

SideEffects []

SeeAlso []

Definition at line 369 of file ifDelay.c.

 {
     pCut->fUser = 1;
     pCut->Cost = pCut->nLeaves > 1 ? 1 : 0;
     pCut->uMaskFunc = 0;
     if ( pCut->nLeaves == 0 ) // const
     {
         assert( Abc_Lit2Var(If_CutTruthLit(pCut)) == 0 );
         return 0;
     }
     if ( pCut->nLeaves == 1 ) // variable
     {
         assert( Abc_Lit2Var(If_CutTruthLit(pCut)) == 1 );
         return (int)If_ObjCutBest(If_CutLeaf(p, pCut, 0))->Delay;
     }
     else
     {
         char * pCutPerm = If_CutDsdPerm( p, pCut );
         int LutSize = p->pPars->pLutStruct[0] - '0';
         int i, pTimes[IF_MAX_FUNC_LUTSIZE];
         int DelayMax = -1, nLeafMax = 0;
         unsigned uLeafMask = 0;
         for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
         {
             pTimes[i] = (int)If_ObjCutBest(If_CutLeaf(p, pCut, Abc_Lit2Var((int)pCutPerm[i])))->Delay; 
             if ( DelayMax < pTimes[i] )
                 DelayMax = pTimes[i], nLeafMax = 1, uLeafMask = (1 << (i << 1));
             else if ( DelayMax == pTimes[i] )
                 nLeafMax++, uLeafMask |= (1 << (i << 1));
         }
         if ( If_CutLeaveNum(pCut) <= LutSize )
             return DelayMax + 1;
         pCut->Cost = 2;
         if ( nLeafMax <= LutSize - 1 )
         {
             pCut->uMaskFunc = If_DsdManCheckXY( p->pIfDsdMan, If_CutDsdLit(p, pCut), LutSize, 1, uLeafMask, 0, 0 );
             if ( pCut->uMaskFunc > 0 )
                 return DelayMax + 1;
         }
         pCut->uMaskFunc = If_DsdManCheckXY( p->pIfDsdMan, If_CutDsdLit(p, pCut), LutSize, 1, 0, 0, 0 );
         if ( pCut->uMaskFunc == 0 )
             return -1;
         return DelayMax + 2;
     }
 }

int If_CutLutBalancePinDelays	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		char *	pPerm
	)

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

Synopsis [Evaluate delay using SOP balancing.]

Description []

SideEffects []

SeeAlso []

Definition at line 327 of file ifDelay.c.

 {
     if ( pCut->nLeaves == 0 ) // const
         return 0;
     if ( pCut->nLeaves == 1 ) // variable
     {
         pPerm[0] = 0;
         return (int)If_ObjCutBest(If_CutLeaf(p, pCut, 0))->Delay;
     }
     else
     {
         char * pCutPerm = If_CutDsdPerm( p, pCut );
         int LutSize = p->pPars->pLutStruct[0] - '0';
         int i, Delay, DelayMax = -1;
         assert( (If_CutLeaveNum(pCut) > LutSize) == (pCut->uMaskFunc > 0) );
         for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
         {
             if ( If_CutLeaveNum(pCut) > LutSize && ((pCut->uMaskFunc >> (i << 1)) & 1) )
                 pPerm[Abc_Lit2Var((int)pCutPerm[i])] = 2;
             else
                 pPerm[Abc_Lit2Var((int)pCutPerm[i])] = 1;
         }
         for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
         {
             Delay = (int)If_ObjCutBest(If_CutLeaf(p, pCut, i))->Delay;
             DelayMax = Abc_MaxInt( DelayMax, Delay + (int)pPerm[i] );
         }
         return DelayMax;
     }
 }

static float If_CutLutDelay	(	If_LibLut_t *	p,
		int	Size,
		int	iPin
	)

inlinestatic

Definition at line 429 of file if.h.

429 { return p ? (p->fVarPinDelays ? p->pLutDelays[Size][iPin] : p->pLutDelays[Size][0]) : 1.0; }

If_LibLut_t_::pLutDelays

float pLutDelays[IF_MAX_LUTSIZE+1][IF_MAX_LUTSIZE+1]

Definition: if.h:176

int fVarPinDelays

Definition: if.h:174

int If_CutMerge	(	If_Man_t *	p,
		If_Cut_t *	pCut0,
		If_Cut_t *	pCut1,
		If_Cut_t *	pCut
	)

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

Synopsis [Prepares the object for FPGA mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 364 of file ifCut.c.

 { 
     int nLutSize = pCut0->nLimit;
     int nSize0 = pCut0->nLeaves;
     int nSize1 = pCut1->nLeaves;
     int * pC0 = pCut0->pLeaves;
     int * pC1 = pCut1->pLeaves;
     int * pC = pCut->pLeaves;
     int i, k, c;
     // compare two cuts with different numbers
     c = nSize0; 
     for ( i = 0; i < nSize1; i++ )
     {
         for ( k = 0; k < nSize0; k++ )
             if ( pC1[i] == pC0[k] )
                 break;
         if ( k < nSize0 )
         {
             p->pPerm[1][i] = k;
             continue;
         }
         if ( c == nLutSize )
             return 0;
         p->pPerm[1][i] = c;
         pC[c++] = pC1[i];
     }
     for ( i = 0; i < nSize0; i++ )
         pC[i] = pC0[i];
     pCut->nLeaves = c;
     pCut->uSign = pCut0->uSign | pCut1->uSign;
     return 1;
 }

int If_CutMergeOrdered	(	If_Man_t *	p,
		If_Cut_t *	pC0,
		If_Cut_t *	pC1,
		If_Cut_t *	pC
	)

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

Synopsis [Prepares the object for FPGA mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 290 of file ifCut.c.

 { 
     int nSizeC0 = pC0->nLeaves;
     int nSizeC1 = pC1->nLeaves;
     int nLimit  = pC0->nLimit;
     int i, k, c, s;
 
     // both cuts are the largest
     if ( nSizeC0 == nLimit && nSizeC1 == nLimit )
     {
         for ( i = 0; i < nSizeC0; i++ )
         {
             if ( pC0->pLeaves[i] != pC1->pLeaves[i] )
                 return 0;
             pC->pLeaves[i] = pC0->pLeaves[i];
         }
         pC->nLeaves = nLimit;
         pC->uSign = pC0->uSign | pC1->uSign;
         return 1;
     }
 
     // compare two cuts with different numbers
     i = k = c = s = 0; 
     if ( nSizeC0 == 0 ) goto FlushCut1;
     if ( nSizeC1 == 0 ) goto FlushCut0;
     while ( 1 )
     {
         if ( c == nLimit ) return 0;
         if ( pC0->pLeaves[i] < pC1->pLeaves[k] )
         {
             pC->pLeaves[c++] = pC0->pLeaves[i++];
             if ( i == nSizeC0 ) goto FlushCut1;
         }
         else if ( pC0->pLeaves[i] > pC1->pLeaves[k] )
         {
             pC->pLeaves[c++] = pC1->pLeaves[k++];
             if ( k == nSizeC1 ) goto FlushCut0;
         }
         else
         {
             pC->pLeaves[c++] = pC0->pLeaves[i++]; k++;
             if ( i == nSizeC0 ) goto FlushCut1;
             if ( k == nSizeC1 ) goto FlushCut0;
         }
     }
 
 FlushCut0:
     if ( c + nSizeC0 > nLimit + i ) return 0;
     while ( i < nSizeC0 )
         pC->pLeaves[c++] = pC0->pLeaves[i++];
     pC->nLeaves = c;
     pC->uSign = pC0->uSign | pC1->uSign;
     return 1;
 
 FlushCut1:
     if ( c + nSizeC1 > nLimit + k ) return 0;
     while ( k < nSizeC1 )
         pC->pLeaves[c++] = pC1->pLeaves[k++];
     pC->nLeaves = c;
     pC->uSign = pC0->uSign | pC1->uSign;
     return 1;
 }

void If_CutOrder ( If_Cut_t * pCut )

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

Synopsis [Orders the leaves of the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 797 of file ifCut.c.

 {
     int i, Temp, fChanges;
     do {
         fChanges = 0;
         for ( i = 0; i < (int)pCut->nLeaves - 1; i++ )
         {
             assert( pCut->pLeaves[i] != pCut->pLeaves[i+1] );
             if ( pCut->pLeaves[i] <= pCut->pLeaves[i+1] )
                 continue;
             Temp = pCut->pLeaves[i];
             pCut->pLeaves[i] = pCut->pLeaves[i+1];
             pCut->pLeaves[i+1] = Temp;
             fChanges = 1;
         }
     } while ( fChanges );
 }

int If_CutPerformCheck07	(	If_Man_t *	p,
		unsigned *	pTruth,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

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

Synopsis [Performs additional check.]

Description []

SideEffects []

SeeAlso []

Definition at line 1071 of file ifDec07.c.

 {
     int fDerive = 0;
     int v;
     // skip non-support minimal
     for ( v = 0; v < nLeaves; v++ )
         if ( !Abc_TtHasVar( (word *)pTruth, nVars, v ) )
             return 0;
     // check
     if ( nLeaves < 5 )
         return 1;
     if ( nLeaves == 5 )
     {
         word z, t = ((word)pTruth[0] << 32) | (word)pTruth[0];
         z = If_Dec5Perform( t, fDerive );
         if ( fDerive && z )
             If_Dec6Verify( t, z );
         return z != 0;
     }
     if ( nLeaves == 6 )
     {
         word z, t = ((word *)pTruth)[0];
         z = If_Dec6Perform( t, fDerive );
         if ( fDerive && z )
         {
 //            If_DecPrintConfig( z );
             If_Dec6Verify( t, z );
         }
 //        if ( z == 0 )
 //            Extra_PrintHex(stdout, (unsigned *)&t, 6), printf( "  " ), Kit_DsdPrintFromTruth( (unsigned *)&t, 6 ), printf( "\n" );
         return z != 0;
     }
     if ( nLeaves == 7 )
     {
         word z, t[2];
         t[0] = ((word *)pTruth)[0];
         t[1] = ((word *)pTruth)[1];
 //        if ( If_Dec7CheckMux(t) >= 0 )
 //            return 1;
         z = If_Dec7Perform( t, fDerive );
         if ( fDerive && z )
             If_Dec7Verify( t, z );
         return z != 0;
     }
     assert( 0 );
     return 0;
 }

int If_CutPerformCheck08	(	If_Man_t *	p,
		unsigned *	pTruth,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

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

Synopsis [Performs additional check.]

Description []

SideEffects []

SeeAlso []

Definition at line 481 of file ifDec08.c.

 {
     int nSupp, fDerive = 0;
     word pF[16];
     if ( nLeaves <= 5 )
         return 1;
     If_Dec08Copy( pF, (word *)pTruth, nVars );
     nSupp = If_Dec08Support( pF, nLeaves );
     if ( !nSupp || !If_DecSuppIsMinBase(nSupp) )
         return 0;
     if ( If_Dec08Perform( pF, nLeaves, fDerive ) )
     {
 //        printf( "1" );
         return 1;
 //        If_Dec08Verify( t, nLeaves, NULL );
     }
 //    printf( "0" );
     return 0;
 }

int If_CutPerformCheck10	(	If_Man_t *	p,
		unsigned *	pTruth,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

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

Synopsis [Performs additional check.]

Description []

SideEffects []

SeeAlso []

Definition at line 480 of file ifDec10.c.

 {
     int nSupp, fDerive = 0;
     word pF[16];
     if ( nLeaves <= 6 )
         return 1;
     If_Dec10Copy( pF, (word *)pTruth, nVars );
     nSupp = If_Dec10Support( pF, nLeaves );
     if ( !nSupp || !If_DecSuppIsMinBase(nSupp) )
         return 0;
     if ( If_Dec10Perform( pF, nLeaves, fDerive ) )
     {
 //        printf( "1" );
         return 1;
 //        If_Dec10Verify( t, nLeaves, NULL );
     }
 //    printf( "0" );
     return 0;
 }

int If_CutPerformCheck16	(	If_Man_t *	p,
		unsigned *	pTruth0,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

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

Synopsis [Performs additional check.]

Description []

SideEffects []

SeeAlso []

Definition at line 2216 of file ifDec16.c.

 {
     unsigned pTruth[IF_MAX_FUNC_LUTSIZE > 5 ? 1 << (IF_MAX_FUNC_LUTSIZE - 5) : 1];
     If_Grp_t G1 = {0};//, G3 = {0};
     int i, nLutLeaf, nLutLeaf2, nLutRoot, Length;
     // stretch the truth table
     assert( nVars >= 6 );
     memcpy( pTruth, pTruth0, sizeof(word) * Abc_TtWordNum(nVars) );
     Abc_TtStretch6( (word *)pTruth, nLeaves, p->pPars->nLutSize );
 
 #ifdef IF_TRY_NEW
     {
         word pCopy[1024];
         int nWords = Abc_TruthWordNum(nVars);
         int iNum;
         if ( s_vTtMem == NULL )
         {
             s_vTtMem = Vec_MemAlloc( Abc_Truth6WordNum(nVars), 12 ); // 32 KB/page for 6-var functions
             Vec_MemHashAlloc( s_vTtMem, 10000 );
         }
         if ( s_vTtMem2 == NULL )
         {
             s_vTtMem2 = Vec_MemAlloc( Abc_Truth6WordNum(nVars), 12 ); // 32 KB/page for 6-var functions
             Vec_MemHashAlloc( s_vTtMem2, 10000 );
         }
         memcpy( pCopy, pTruth, sizeof(word) * Abc_Truth6WordNum(nVars) );
         if ( pCopy[0] & 1 )
             for ( i = 0; i < nWords; i++ )
                 pCopy[i] = ~pCopy[i];
         iNum = Vec_MemHashInsert( s_vTtMem, pCopy );
         if ( iNum == Vec_MemEntryNum(s_vTtMem) - 1 )
         {
             int pCanonPerm[16];
             char pCanonPermC[16];
             Abc_TtCanonicize( pCopy, nVars, pCanonPermC );
 //            If_CluSemiCanonicize( pCopy, nVars, pCanonPerm );
             Vec_MemHashInsert( s_vTtMem2, pCopy );
         }
     }
 #endif
 
     // if cutmin is disabled, minimize the function
     if ( !p->pPars->fCutMin )
         nLeaves = Abc_TtMinBase( (word *)pTruth, NULL, nLeaves, nVars );
 
     // quit if parameters are wrong
     Length = strlen(pStr);
     if ( Length != 2 && Length != 3 )
     {
         printf( "Wrong LUT struct (%s)\n", pStr );
         return 0;
     }
     for ( i = 0; i < Length; i++ )
         if ( pStr[i] - '0' < 3 || pStr[i] - '0' > 6 )
         {
             printf( "The LUT size (%d) should belong to {3,4,5,6}.\n", pStr[i] - '0' );
             return 0;
         }
 
     nLutLeaf  =                   pStr[0] - '0';
     nLutLeaf2 = ( Length == 3 ) ? pStr[1] - '0' : 0;
     nLutRoot  =                   pStr[Length-1] - '0';
     if ( nLeaves > nLutLeaf - 1 + (nLutLeaf2 ? nLutLeaf2 - 1 : 0) + nLutRoot )
     {
         printf( "The cut size (%d) is too large for the LUT structure %s.\n", nLeaves, pStr );
         return 0;
     }
     // consider easy case
     if ( nLeaves <= Abc_MaxInt( nLutLeaf2, Abc_MaxInt(nLutLeaf, nLutRoot) ) )
         return 1;
 
     // derive the first group
     if ( Length == 2 )
         G1 = If_CluCheck( p, (word *)pTruth, nLeaves, 0, 0, nLutLeaf, nLutRoot, NULL, NULL, NULL, NULL, 1 );
     else
         G1 = If_CluCheck3( p, (word *)pTruth, nLeaves, nLutLeaf, nLutLeaf2, nLutRoot, NULL, NULL, NULL, NULL, NULL );
 
 //    if ( G1.nVars > 0 )
 //        If_CluPrintGroup( &G1 );
 
     return (int)(G1.nVars > 0);
 }

int If_CutPerformCheck45	(	If_Man_t *	p,
		unsigned *	pTruth,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

Definition at line 1865 of file ifDec16.c.

 {    
     // 5LUT -> 4LUT
     If_Grp_t G, R;
     word Func0, Func1;
     G = If_CluCheck( p, (word *)pTruth, nLeaves, 0, 0, 5, 4, &R, &Func0, &Func1, NULL, 0 );
     if ( G.nVars == 0 )
         return 0;
     Func0 = If_CluAdjust( Func0, R.nVars );
     Func1 = If_CluAdjust( Func1, G.nVars );
 #if 0
     Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" );
     Kit_DsdPrintFromTruth( (unsigned*)&Func0, R.nVars ); printf( "\n" );
     Kit_DsdPrintFromTruth( (unsigned*)&Func1, G.nVars ); printf( "\n" );
     If_CluPrintGroup( &R );
     If_CluPrintGroup( &G );
 #endif
     if ( G.nVars < 5 || (p->pPars->fEnableCheck75 && If_CluCheckDecOut(Func1, 5)) || (p->pPars->fEnableCheck75u && If_CluCheckDecOutU(Func1, 5)) )
         return 1;
     return 0;
 }

int If_CutPerformCheck54	(	If_Man_t *	p,
		unsigned *	pTruth,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

Definition at line 1886 of file ifDec16.c.

 {    
     // 4LUT -> 5LUT
     If_Grp_t G, R;
     word Func0, Func1;
     G = If_CluCheck( p, (word *)pTruth, nLeaves, 0, 0, 4, 5, &R, &Func0, &Func1, NULL, 0 );
     if ( G.nVars == 0 )
         return 0;
     Func0 = If_CluAdjust( Func0, R.nVars );
     Func1 = If_CluAdjust( Func1, G.nVars );
 #if 0
     Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" );
     Kit_DsdPrintFromTruth( (unsigned*)&Func0, R.nVars ); printf( "\n" );
     Kit_DsdPrintFromTruth( (unsigned*)&Func1, G.nVars ); printf( "\n" );
     If_CluPrintGroup( &R );
     If_CluPrintGroup( &G );
 #endif
     if ( R.nVars < 5 || (p->pPars->fEnableCheck75 && If_CluCheckDecIn(Func0, 5)) || (p->pPars->fEnableCheck75u && If_CluCheckDecInU(Func0, 5)) )
         return 1;
     return 0;
 }

int If_CutPerformCheck75	(	If_Man_t *	p,
		unsigned *	pTruth0,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

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

Synopsis [Performs additional check.]

Description []

SideEffects []

SeeAlso []

Definition at line 303 of file ifDec75.c.

 {
     word * pTruthW = (word *)pTruth0;
     word pTruth[4] = { pTruthW[0], pTruthW[1], pTruthW[2], pTruthW[3] };
     assert( nLeaves <= 8 );
     if ( !p->pPars->fCutMin )
         Abc_TtMinimumBase( pTruth, NULL, nLeaves, &nLeaves );
     if ( nLeaves < 6 )
         return 1;
 //    if ( nLeaves < 8 && If_CutPerformCheck07( p, (unsigned *)pTruth, nVars, nLeaves, "44" ) )
     if ( nLeaves < 8 && If_CutPerformCheck16( p, (unsigned *)pTruth, nVars, nLeaves, "44" ) )
         return 1;
     // this is faster but not compatible with -z
     if ( !p->pPars->fDeriveLuts && p->pPars->fEnableCheck75 && nLeaves == 8 )
     {
 //        char pDsdStr[1000] = "(!(abd)!(c!([fe][gh])))";
         char pDsdStr[1000];
         int nSizeNonDec = Dau_DsdDecompose( (word *)pTruth, nLeaves, 0, 0, pDsdStr );
         if ( nSizeNonDec >= 5 )
             return 0;
         if ( Dau_DsdCheckDecAndExist(pDsdStr) & 0x10 ) // bit 4
             return 1;
         return 0;
     }
     if ( If_CutPerformCheck45( p, (unsigned *)pTruth, nVars, nLeaves, pStr ) )
         return 1;
     if ( If_CutPerformCheck54( p, (unsigned *)pTruth, nVars, nLeaves, pStr ) )
         return 1;
     return 0;
 }

word If_CutPerformDerive07	(	If_Man_t *	p,
		unsigned *	pTruth,
		int	nVars,
		int	nLeaves,
		char *	pStr
	)

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

Synopsis [Performs additional check.]

Description []

SideEffects []

SeeAlso []

Definition at line 1029 of file ifDec07.c.

 {
     if ( nLeaves < 5 )
         return 1;
     if ( nLeaves == 5 )
     {
         word z, t = ((word)pTruth[0] << 32) | (word)pTruth[0];
         z = If_Dec5Perform( t, 1 );
         If_Dec6Verify( t, z );
         return z;
     }
     if ( nLeaves == 6 )
     {
         word z, t = ((word *)pTruth)[0];
         z = If_Dec6Perform( t, 1 );
         If_Dec6Verify( t, z );
         return z;
     }
     if ( nLeaves == 7 )
     {
         word z, t[2];
         t[0] = ((word *)pTruth)[0];
         t[1] = ((word *)pTruth)[1];
         z = If_Dec7Perform( t, 1 );
         If_Dec7Verify( t, z );
         return z;
     }
     assert( 0 );
     return 0;
 }

static char* If_CutPerm ( If_Cut_t * pCut )

inlinestatic

Definition at line 397 of file if.h.

397 { return (char *)(pCut->pLeaves + pCut->nLeaves); }

unsigned nLeaves

Definition: if.h:289

int pLeaves[0]

Definition: if.h:290

static int If_CutPermWords ( int nVarsMax )

inlinestatic

Definition at line 395 of file if.h.

395 { return nVarsMax / sizeof(int) + ((nVarsMax % sizeof(int)) > 0); }

float If_CutPowerDeref	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		If_Obj_t *	pRoot
	)

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

Synopsis [Computes area of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1234 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     float * pSwitching = (float *)p->vSwitching->pArray;
     float Power = 0;
     int i;
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         Power += pSwitching[pLeaf->Id];
         assert( pLeaf->nRefs > 0 );
         if ( --pLeaf->nRefs > 0 || !If_ObjIsAnd(pLeaf) )
             continue;
         Power += If_CutPowerDeref( p, If_ObjCutBest(pLeaf), pRoot );
     }
     return Power;
 }

float If_CutPowerDerefed	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		If_Obj_t *	pRoot
	)

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

Synopsis [Computes Power of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1290 of file ifCut.c.

 {
     float aResult, aResult2;
     if ( pCut->nLeaves < 2 )
         return 0;
     aResult2 = If_CutPowerRef( p, pCut, pRoot );
     aResult  = If_CutPowerDeref( p, pCut, pRoot );
     assert( aResult > aResult2 - p->fEpsilon );
     assert( aResult < aResult2 + p->fEpsilon );
     return aResult;
 }

float If_CutPowerFlow	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		If_Obj_t *	pRoot
	)

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

Synopsis [Computes area flow.]

Description []

SideEffects []

SeeAlso []

Definition at line 979 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     float * pSwitching = (float *)p->vSwitching->pArray;
     float Power = 0;
     int i;
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         Power += pSwitching[pLeaf->Id];
         if ( pLeaf->nRefs == 0 || If_ObjIsConst1(pLeaf) )
             Power += If_ObjCutBest(pLeaf)->Power;
         else 
         {
             assert( pLeaf->EstRefs > p->fEpsilon );
             Power += If_ObjCutBest(pLeaf)->Power / pLeaf->EstRefs;
         }
     }
     return Power;
 }

float If_CutPowerRef	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		If_Obj_t *	pRoot
	)

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

Synopsis [Computes area of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1262 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     float * pSwitching = (float *)p->vSwitching->pArray;
     float Power = 0;
     int i;
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         Power += pSwitching[pLeaf->Id];
         assert( pLeaf->nRefs >= 0 );
         if ( pLeaf->nRefs++ > 0 || !If_ObjIsAnd(pLeaf) )
             continue;
         Power += If_CutPowerRef( p, If_ObjCutBest(pLeaf), pRoot );
     }
     return Power;
 }

float If_CutPowerRefed	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		If_Obj_t *	pRoot
	)

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

Synopsis [Computes area of the first level.]

Description [The cut need to be derefed.]

SideEffects []

SeeAlso []

Definition at line 1313 of file ifCut.c.

 {
     float aResult, aResult2;
     if ( pCut->nLeaves < 2 )
         return 0;
     aResult2 = If_CutPowerDeref( p, pCut, pRoot );
     aResult  = If_CutPowerRef( p, pCut, pRoot );
     assert( aResult > aResult2 - p->fEpsilon );
     assert( aResult < aResult2 + p->fEpsilon );
     return aResult;
 }

void If_CutPrint ( If_Cut_t * pCut )

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

Synopsis [Prints one cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 856 of file ifCut.c.

 {
     unsigned i;
     Abc_Print( 1, "{" );
     for ( i = 0; i < pCut->nLeaves; i++ )
         Abc_Print( 1, " %s%d", If_CutLeafBit(pCut, i) ? "!":"", pCut->pLeaves[i] );
     Abc_Print( 1, " }\n" );
 }

void If_CutPrintTiming	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

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

Synopsis [Prints one cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 876 of file ifCut.c.

 {
     If_Obj_t * pLeaf;
     unsigned i;
     Abc_Print( 1, "{" );
     If_CutForEachLeaf( p, pCut, pLeaf, i )
         Abc_Print( 1, " %d(%.2f/%.2f)", pLeaf->Id, If_ObjCutBest(pLeaf)->Delay, pLeaf->Required );
     Abc_Print( 1, " }\n" );
 }

void If_CutPropagateRequired	(	If_Man_t *	p,
		If_Obj_t *	pObj,
		If_Cut_t *	pCut,
		float	ObjRequired
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file ifTime.c.

 {
     static int pPinPerm[IF_MAX_LUTSIZE];
     static float pPinDelays[IF_MAX_LUTSIZE];
     If_Obj_t * pLeaf;
     float * pLutDelays;
     float Required;
     int i, Pin2PinDelay;//, iLeaf;
     assert( !p->pPars->fLiftLeaves );
     // compute the pins
     if ( p->pPars->pLutLib )
     {
         pLutDelays = p->pPars->pLutLib->pLutDelays[pCut->nLeaves];
         if ( p->pPars->pLutLib->fVarPinDelays )
         {
             // compute the delay using sorted pins
             If_CutSortInputPins( p, pCut, pPinPerm, pPinDelays );
             for ( i = 0; i < (int)pCut->nLeaves; i++ )
             {
                 Required = ObjRequired - pLutDelays[i];
                 pLeaf = If_ManObj( p, pCut->pLeaves[pPinPerm[i]] );
                 pLeaf->Required = IF_MIN( pLeaf->Required, Required );
             }
         }
         else
         {
             Required = ObjRequired;
             If_CutForEachLeaf( p, pCut, pLeaf, i )
                 pLeaf->Required = IF_MIN( pLeaf->Required, Required - pLutDelays[0] );
         }
     }
     else
     {
         if ( pCut->fUser )
         {
             char Perm[IF_MAX_FUNC_LUTSIZE], * pPerm = Perm;
             if ( p->pPars->fDelayOpt )
             {
                 int Delay = If_CutSopBalancePinDelays( p, pCut, pPerm );
                 assert( Delay == (int)pCut->Delay );
             }
             else if ( p->pPars->fDelayOptLut )
             {
                 int Delay = If_CutLutBalancePinDelays( p, pCut, pPerm );
                 assert( Delay == (int)pCut->Delay );
             }
             else if ( p->pPars->fDsdBalance )
             {
                 int Delay = If_CutDsdBalancePinDelays( p, pCut, pPerm );
                 assert( Delay == (int)pCut->Delay );
             }
             else
                 pPerm = If_CutPerm(pCut);
             If_CutForEachLeaf( p, pCut, pLeaf, i )
             {
                 Pin2PinDelay = pPerm ? (pPerm[i] == IF_BIG_CHAR ? -IF_BIG_CHAR : pPerm[i]) : 1;
                 Required = ObjRequired - (float)Pin2PinDelay;
                 pLeaf->Required = IF_MIN( pLeaf->Required, Required );
             }
         }
         else
         {
             Required = ObjRequired;
             If_CutForEachLeaf( p, pCut, pLeaf, i )
                 pLeaf->Required = IF_MIN( pLeaf->Required, Required - (float)1.0 );
         }
     }
 }

void If_CutRotatePins	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

Definition at line 67 of file ifTruth.c.

 {
     If_Obj_t * pLeaf;
     float PinDelays[IF_MAX_LUTSIZE];
     int i, truthId;
     assert( !p->pPars->fUseTtPerm );
     If_CutForEachLeaf( p, pCut, pLeaf, i )
         PinDelays[i] = If_ObjCutBest(pLeaf)->Delay;
     if ( p->vTtMem[pCut->nLeaves] == NULL )
     {
         If_CutTruthPermute( NULL, If_CutLeaveNum(pCut), pCut->nLeaves, p->nTruth6Words[pCut->nLeaves], PinDelays, If_CutLeaves(pCut) );
         return;
     }
     Abc_TtCopy( p->puTempW, If_CutTruthWR(p, pCut), p->nTruth6Words[pCut->nLeaves], 0 );
     If_CutTruthPermute( p->puTempW, If_CutLeaveNum(pCut), pCut->nLeaves, p->nTruth6Words[pCut->nLeaves], PinDelays, If_CutLeaves(pCut) );
     truthId        = Vec_MemHashInsert( p->vTtMem[pCut->nLeaves], p->puTempW );
     pCut->iCutFunc = Abc_Var2Lit( truthId, If_CutTruthIsCompl(pCut) );
     assert( (p->puTempW[0] & 1) == 0 );
 }

static void If_CutSetData	(	If_Cut_t *	pCut,
		void *	pData
	)

inlinestatic

Definition at line 412 of file if.h.

412 { *(void **)pCut = pData; }

static void If_CutSetDataInt	(	If_Cut_t *	pCut,
		int	Data
	)

inlinestatic

Definition at line 415 of file if.h.

415 { *(int *)pCut = Data; }

static void If_CutSetup	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 399 of file if.h.

399 { memset(pCut, 0, p->nCutBytes); pCut->nLimit = p->pPars->nLutSize; }

memset

char * memset()

If_Cut_t_::nLimit

unsigned nLimit

Definition: if.h:288

If_Par_t_::nLutSize

int nLutSize

Definition: if.h:103

If_Par_t * pPars

Definition: if.h:184

If_Man_t_::nCutBytes

int nCutBytes

Definition: if.h:229

int If_CutSopBalanceEval	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		Vec_Int_t *	vAig
	)

Definition at line 248 of file ifDelay.c.

 {
     pCut->fUser = 1;
     if ( vAig )
         Vec_IntClear( vAig );
     if ( pCut->nLeaves == 0 ) // const
     {
         assert( Abc_Lit2Var(If_CutTruthLit(pCut)) == 0 );
         if ( vAig )
             Vec_IntPush( vAig, Abc_LitIsCompl(If_CutTruthLit(pCut)) );
         pCut->Cost = 0;
         return 0;
     }
     if ( pCut->nLeaves == 1 ) // variable
     {
         assert( Abc_Lit2Var(If_CutTruthLit(pCut)) == 1 );
         if ( vAig )
             Vec_IntPush( vAig, 0 );
         if ( vAig )
             Vec_IntPush( vAig, Abc_LitIsCompl(If_CutTruthLit(pCut)) );
         pCut->Cost = 0;
         return (int)If_ObjCutBest(If_CutLeaf(p, pCut, 0))->Delay;
     }
     else
     {
         int fVerbose = 0;
         Vec_Int_t * vCover = Vec_WecEntry( p->vTtIsops[pCut->nLeaves], Abc_Lit2Var(If_CutTruthLit(pCut)) );
         int Delay, Area = 0;
         int i, pTimes[IF_MAX_FUNC_LUTSIZE];
         if ( vCover == NULL )
             return -1;
         assert( Vec_IntSize(vCover) > 0 );
         for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
             pTimes[i] = (int)If_ObjCutBest(If_CutLeaf(p, pCut, i))->Delay; 
         Delay = If_CutSopBalanceEvalIntInt( vCover, If_CutLeaveNum(pCut), pTimes, vAig, Abc_LitIsCompl(If_CutTruthLit(pCut)) ^ pCut->fCompl, &Area );
         pCut->Cost = Area;
         if ( fVerbose )
         {
             int Max = 0, Two = 0;
             for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
                 Max = Abc_MaxInt( Max, pTimes[i] );
             for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
                 if ( pTimes[i] != Max )
                     Two = Abc_MaxInt( Two, pTimes[i] );
             if ( Two + 2 < Max && Max + 3 < Delay )
             {
                 for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
                     printf( "%3d ", pTimes[i] );
                 for ( ; i < p->pPars->nLutSize; i++ )
                     printf( "    " );
                 printf( "-> %3d   ", Delay );
                 Dau_DsdPrintFromTruth( If_CutTruthW(p, pCut), If_CutLeaveNum(pCut) );
                 Kit_TruthIsopPrintCover( vCover, If_CutLeaveNum(pCut), Abc_LitIsCompl(If_CutTruthLit(pCut)) ^ pCut->fCompl );
                 {
                     Vec_Int_t vIsop;
                     int pIsop[64];
                     vIsop.nCap = vIsop.nSize = Abc_Tt6Esop( *If_CutTruthW(p, pCut), pCut->nLeaves, pIsop );
                     vIsop.pArray = pIsop;
                     printf( "ESOP (%d -> %d)\n", Vec_IntSize(vCover), vIsop.nSize );
                     Kit_TruthIsopPrintCover( &vIsop, If_CutLeaveNum(pCut), 0 );
                 }
                 printf( "\n" );
             }
         }
         return Delay;
     }
 }

int If_CutSopBalanceEvalInt	(	Vec_Int_t *	vCover,
		int *	pTimes,
		int *	pFaninLits,
		Vec_Int_t *	vAig,
		int *	piRes,
		int	nSuppAll,
		int *	pArea
	)

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

Synopsis [Evaluate delay using SOP balancing.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file ifDelay.c.

 {
     int nCounterAnd, pCounterAnd[IF_MAX_FUNC_LUTSIZE], pFaninLitsAnd[IF_MAX_FUNC_LUTSIZE];
     int nCounterOr,  pCounterOr[IF_MAX_CUBES],  pFaninLitsOr[IF_MAX_CUBES];
     int i, k, Entry, Literal, nLits, Delay = 0, iRes = 0;
     if ( Vec_IntSize(vCover) > IF_MAX_CUBES )
         return -1;
     nCounterOr = 0;
     Vec_IntForEachEntry( vCover, Entry, i )
     { 
         nCounterAnd = nLits = 0;
         for ( k = 0; k < nSuppAll; k++ )
         {
             Literal = 3 & (Entry >> (k << 1));
             if ( Literal == 1 ) // neg literal
                 nLits++, Delay = If_LogCounterAddAig( pCounterAnd, &nCounterAnd, pFaninLitsAnd, pTimes[k], Abc_LitNot(pFaninLits[k]), vAig, nSuppAll, 0, 0 );
             else if ( Literal == 2 ) // pos literal
                 nLits++, Delay = If_LogCounterAddAig( pCounterAnd, &nCounterAnd, pFaninLitsAnd, pTimes[k], pFaninLits[k], vAig, nSuppAll, 0, 0 );
             else if ( Literal != 0 ) 
                 assert( 0 );
         }
         assert( nCounterAnd > 0 );
         assert( nLits > 0 );
         if ( vAig )
             iRes = If_LogCreateAndXorMulti( vAig, pFaninLitsAnd, nCounterAnd, nSuppAll, 0 );
         else
             *pArea += nLits == 1 ? 0 : nLits - 1;
         Delay = If_LogCounterAddAig( pCounterOr, &nCounterOr, pFaninLitsOr, Delay, Abc_LitNot(iRes), vAig, nSuppAll, 0, 0 );
     }
     assert( nCounterOr > 0 );
     if ( vAig )
     {
         *piRes = Abc_LitNot( If_LogCreateAndXorMulti( vAig, pFaninLitsOr, nCounterOr, nSuppAll, 0 ) );
         if ( ((vCover->nCap >> 16) & 1) )  // hack to remember complemented attribute
             *piRes = Abc_LitNot( *piRes );
     }
     else       
         *pArea += Vec_IntSize(vCover) == 1 ? 0 : Vec_IntSize(vCover) - 1;
     return Delay;
 }

int If_CutSopBalancePinDelays	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		char *	pPerm
	)

Definition at line 159 of file ifDelay.c.

 {
     if ( pCut->nLeaves == 0 ) // const
         return 0;
     if ( pCut->nLeaves == 1 ) // variable
     {
         pPerm[0] = 0;
         return (int)If_ObjCutBest(If_CutLeaf(p, pCut, 0))->Delay;
     }
     else
     {
         Vec_Int_t * vCover;
         int i, pTimes[IF_MAX_FUNC_LUTSIZE];
         vCover = Vec_WecEntry( p->vTtIsops[pCut->nLeaves], Abc_Lit2Var(If_CutTruthLit(pCut)) );
         if ( Vec_IntSize(vCover) == 0 )
             return -1;
         for ( i = 0; i < If_CutLeaveNum(pCut); i++ )
             pTimes[i] = (int)If_ObjCutBest(If_CutLeaf(p, pCut, i))->Delay; 
         return If_CutSopBalancePinDelaysIntInt( vCover, pTimes, If_CutLeaveNum(pCut), pPerm );
     }
 }

int If_CutSopBalancePinDelaysInt	(	Vec_Int_t *	vCover,
		int *	pTimes,
		word *	pFaninRes,
		int	nSuppAll,
		word *	pRes
	)

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

Synopsis [Compute pin delays.]

Description []

SideEffects []

SeeAlso []

Definition at line 120 of file ifDelay.c.

 {
     word pPinDelsAnd[IF_MAX_FUNC_LUTSIZE], pPinDelsOr[IF_MAX_CUBES];
     int nCounterAnd, pCounterAnd[IF_MAX_FUNC_LUTSIZE];
     int nCounterOr,  pCounterOr[IF_MAX_CUBES];
     int i, k, Entry, Literal, Delay = 0;
     word ResAnd;
     if ( Vec_IntSize(vCover) > IF_MAX_CUBES )
         return -1;
     nCounterOr = 0;
     Vec_IntForEachEntry( vCover, Entry, i )
     { 
         nCounterAnd = 0;
         for ( k = 0; k < nSuppAll; k++ )
         {
             Literal = 3 & (Entry >> (k << 1));
             if ( Literal == 1 || Literal == 2 ) // neg or pos literal
                 Delay = If_LogCounterPinDelays( pCounterAnd, &nCounterAnd, pPinDelsAnd, pTimes[k], pFaninRes[k], nSuppAll, 0 );
             else if ( Literal != 0 ) 
                 assert( 0 );
         }
         assert( nCounterAnd > 0 );
         ResAnd = If_LogPinDelaysMulti( pPinDelsAnd, nCounterAnd, nSuppAll, 0 );
         Delay = If_LogCounterPinDelays( pCounterOr, &nCounterOr, pPinDelsOr, Delay, ResAnd, nSuppAll, 0 );
     }
     assert( nCounterOr > 0 );
     *pRes = If_LogPinDelaysMulti( pPinDelsOr, nCounterOr, nSuppAll, 0 );
     return Delay;
 }

void If_CutSort	(	If_Man_t *	p,
		If_Set_t *	pCutSet,
		If_Cut_t *	pCut
	)

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

Synopsis [Performs incremental sorting of cuts.]

Description [Currently only the trivial sorting is implemented.]

SideEffects []

SeeAlso []

Definition at line 738 of file ifCut.c.

 {
 //    int Counter = 0;
     int i;
 
     // the new cut is the last one
     assert( pCutSet->ppCuts[pCutSet->nCuts] == pCut );
     assert( pCutSet->nCuts <= pCutSet->nCutsMax );
 
     // cut structure is empty
     if ( pCutSet->nCuts == 0 )
     {
         pCutSet->nCuts++;
         return;
     }
 
     if ( !pCut->fUseless && 
          (p->pPars->fUseDsd || p->pPars->fUseBat || 
           p->pPars->pLutStruct || p->pPars->fUserRecLib || 
           p->pPars->fEnableCheck07 || p->pPars->fUseCofVars || p->pPars->fUseAndVars || 
           p->pPars->fUseDsdTune || p->pPars->fEnableCheck75 || p->pPars->fEnableCheck75u) )
     {
         If_Cut_t * pFirst = pCutSet->ppCuts[0];
         if ( pFirst->fUseless || If_ManSortCompare(p, pFirst, pCut) == 1 )
         {
             pCutSet->ppCuts[0] = pCut;
             pCutSet->ppCuts[pCutSet->nCuts] = pFirst;
             If_CutSort( p, pCutSet, pFirst );
             return;
         }
     }
 
     // the cut will be added - find its place
     for ( i = pCutSet->nCuts-1; i >= 0; i-- )
     {
 //        Counter++;
         if ( If_ManSortCompare( p, pCutSet->ppCuts[i], pCut ) <= 0 || (i == 0 && !pCutSet->ppCuts[0]->fUseless && pCut->fUseless) )
             break;
         pCutSet->ppCuts[i+1] = pCutSet->ppCuts[i];
         pCutSet->ppCuts[i] = pCut;
     }
 //    Abc_Print( 1, "%d ", Counter );
 
     // update the number of cuts
     if ( pCutSet->nCuts < pCutSet->nCutsMax )
         pCutSet->nCuts++;
 }

static unsigned If_CutSuppMask ( If_Cut_t * pCut )

inlinestatic

Definition at line 393 of file if.h.

393 { return (~(unsigned)0) >> (32-pCut->nLeaves); }

unsigned nLeaves

Definition: if.h:289

void If_CutTraverse	(	If_Man_t *	p,
		If_Obj_t *	pRoot,
		If_Cut_t *	pCut,
		Vec_Ptr_t *	vNodes
	)

Definition at line 565 of file ifUtil.c.

 {
     If_Obj_t * pLeaf;
     int i;
     // collect the internal nodes of the cut
     Vec_PtrClear( vNodes );
     If_CutForEachLeaf( p, pCut, pLeaf, i )
     {
         Vec_PtrPush( vNodes, pLeaf );
         assert( pLeaf->fMark == 0 );
         pLeaf->fMark = 1;
     }
     // collect other nodes
     If_CutTraverse_rec( pRoot, vNodes );
     // clean the mark
     Vec_PtrForEachEntry( If_Obj_t *, vNodes, pLeaf, i )
         pLeaf->fMark = 0;
 }

static unsigned* If_CutTruth	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 422 of file if.h.

422 { return (unsigned *)If_CutTruthW(p, pCut); }

If_CutTruthW

static word * If_CutTruthW(If_Man_t *p, If_Cut_t *pCut)

Definition: if.h:421

static int If_CutTruthIsCompl ( If_Cut_t * pCut )

inlinestatic

Definition at line 418 of file if.h.

418 { assert( pCut->iCutFunc >= 0 ); return Abc_LitIsCompl(pCut->iCutFunc); }

Abc_LitIsCompl

static int Abc_LitIsCompl(int Lit)

Definition: abc_global.h:265

#define assert(ex)

Definition: util_old.h:213

int iCutFunc

Definition: if.h:281

static int If_CutTruthLit ( If_Cut_t * pCut )

inlinestatic

Definition at line 417 of file if.h.

417 { assert( pCut->iCutFunc >= 0 ); return pCut->iCutFunc; }

#define assert(ex)

Definition: util_old.h:213

int iCutFunc

Definition: if.h:281

static unsigned* If_CutTruthUR	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 420 of file if.h.

420 { return (unsigned *)If_CutTruthWR(p, pCut); }

If_CutTruthWR

static word * If_CutTruthWR(If_Man_t *p, If_Cut_t *pCut)

Definition: if.h:419

static word* If_CutTruthW	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 421 of file if.h.

421 { if ( p->vTtMem == NULL ) return NULL; assert( pCut->iCutFunc >= 0 ); Abc_TtCopy( p->puTempW, If_CutTruthWR(p, pCut), p->nTruth6Words[pCut->nLeaves], If_CutTruthIsCompl(pCut) ); return p->puTempW; }

If_Man_t_::nTruth6Words

int nTruth6Words[IF_MAX_FUNC_LUTSIZE+1]

Definition: if.h:226

unsigned nLeaves

Definition: if.h:289

If_Man_t_::vTtMem

Vec_Mem_t * vTtMem[IF_MAX_FUNC_LUTSIZE+1]

Definition: if.h:244

If_CutTruthIsCompl

static int If_CutTruthIsCompl(If_Cut_t *pCut)

Definition: if.h:418

Abc_TtCopy

static void Abc_TtCopy(word *pOut, word *pIn, int nWords, int fCompl)

Definition: utilTruth.h:221

If_CutTruthWR

static word * If_CutTruthWR(If_Man_t *p, If_Cut_t *pCut)

Definition: if.h:419

If_Man_t_::puTempW

word * puTempW

Definition: if.h:204

#define assert(ex)

Definition: util_old.h:213

int iCutFunc

Definition: if.h:281

static int If_CutTruthWords ( int nVarsMax )

inlinestatic

Definition at line 394 of file if.h.

394 { return nVarsMax <= 5 ? 2 : (1 << (nVarsMax - 5)); }

static word* If_CutTruthWR	(	If_Man_t *	p,
		If_Cut_t *	pCut
	)

inlinestatic

Definition at line 419 of file if.h.

419 { return p->vTtMem ? Vec_MemReadEntry(p->vTtMem[pCut->nLeaves], Abc_Lit2Var(pCut->iCutFunc)) : NULL; }

unsigned nLeaves

Definition: if.h:289

If_Man_t_::vTtMem

Vec_Mem_t * vTtMem[IF_MAX_FUNC_LUTSIZE+1]

Definition: if.h:244

Abc_Lit2Var

static int Abc_Lit2Var(int Lit)

Definition: abc_global.h:264

Vec_MemReadEntry

static word * Vec_MemReadEntry(Vec_Mem_t *p, int i)

Definition: vecMem.h:191

int iCutFunc

Definition: if.h:281

int If_CutVerifyCuts	(	If_Set_t *	pCutSet,
		int	fOrdered
	)

Definition at line 62 of file ifCut.c.

 {
     static int Count = 0;
     If_Cut_t * pCut0, * pCut1; 
     int i, k, m, n, Value;
     assert( pCutSet->nCuts > 0 );
     for ( i = 0; i < pCutSet->nCuts; i++ )
     {
         pCut0 = pCutSet->ppCuts[i];
         assert( pCut0->uSign == If_ObjCutSignCompute(pCut0) );
         if ( fOrdered )
         {
             // check duplicates
             for ( m = 1; m < (int)pCut0->nLeaves; m++ )
                 assert( pCut0->pLeaves[m-1] < pCut0->pLeaves[m] );
         }
         else
         {
             // check duplicates
             for ( m = 0; m < (int)pCut0->nLeaves; m++ )
             for ( n = m+1; n < (int)pCut0->nLeaves; n++ )
             assert( pCut0->pLeaves[m] != pCut0->pLeaves[n] );
         }
         // check pairs
         for ( k = 0; k < pCutSet->nCuts; k++ )
         {
             pCut1 = pCutSet->ppCuts[k];
             if ( pCut0 == pCut1 )
                 continue;
             Count++;
             // check containments
             Value = If_CutVerifyCut( pCut0, pCut1 );
 //            assert( Value == 0 );
             if ( Value )
             {
                 assert( pCut0->uSign == If_ObjCutSignCompute(pCut0) );
                 assert( pCut1->uSign == If_ObjCutSignCompute(pCut1) );
                 If_CutPrint( pCut0 );
                 If_CutPrint( pCut1 );
                 assert( 0 );
             }
         }
     }
     return 1;
 }

If_DsdMan_t* If_DsdManAlloc	(	int	nVars,
		int	nLutSize
	)

Definition at line 248 of file ifDsd.c.

 {
     If_DsdMan_t * p; int v;
     char pFileName[10];
     assert( nVars <= DAU_MAX_VAR );
     sprintf( pFileName, "%02d.dsd", nVars );
     p = ABC_CALLOC( If_DsdMan_t, 1 );
     p->pStore  = Abc_UtilStrsav( pFileName );
     p->nVars   = nVars;
     p->LutSize = LutSize;
     p->nWords  = Abc_TtWordNum( nVars );
     p->nBins   = Abc_PrimeCudd( 100000 );
     p->pBins   = ABC_CALLOC( unsigned, p->nBins );
     p->pMem    = Mem_FlexStart();
     Vec_PtrGrow( &p->vObjs, 10000 );
     Vec_IntGrow( &p->vNexts, 10000 );
     Vec_IntGrow( &p->vTruths, 10000 );
     If_DsdObjAlloc( p, IF_DSD_CONST0, 0 );
     If_DsdObjAlloc( p, IF_DSD_VAR, 0 )->nSupp = 1;
     p->vTemp1   = Vec_IntAlloc( 32 );
     p->vTemp2   = Vec_IntAlloc( 32 );
     p->pTtElems = If_ManDsdTtElems();
     for ( v = 3; v <= nVars; v++ )
     {
         p->vTtMem[v] = Vec_MemAlloc( Abc_TtWordNum(v), 12 );
         Vec_MemHashAlloc( p->vTtMem[v], 10000 );
         p->vTtDecs[v] = Vec_PtrAlloc( 1000 );
     }
 /*
     p->pTtGia   = Gia_ManStart( nVars );
     Gia_ManHashAlloc( p->pTtGia );
     for ( v = 0; v < nVars; v++ )
         Gia_ManAppendCi( p->pTtGia );
 */
     for ( v = 2; v < nVars; v++ )
         p->pSched[v] = Extra_GreyCodeSchedule( v );
     if ( LutSize )
     p->pSat     = If_ManSatBuildXY( LutSize );
     p->vCover   = Vec_IntAlloc( 0 );
     return p;
 }

void If_DsdManAllocIsops	(	If_DsdMan_t *	p,
		int	nLutSize
	)

Definition at line 289 of file ifDsd.c.

 {
     Vec_Int_t * vLevel;
     int v, i, fCompl;
     word * pTruth;
     if ( p->vIsops[3] != NULL )
         return;
     if ( Vec_PtrSize(&p->vObjs) > 2 )
         printf( "Warning: DSD manager is already started without ISOPs.\n" );
     for ( v = 3; v <= nLutSize; v++ )
     {
         p->vIsops[v] = Vec_WecAlloc( 100 );
         Vec_MemForEachEntry( p->vTtMem[v], pTruth, i )
         {
             vLevel = Vec_WecPushLevel( p->vIsops[v] );
             fCompl = Kit_TruthIsop( (unsigned *)pTruth, v, p->vCover, 1 );
             if ( fCompl >= 0 && Vec_IntSize(p->vCover) <= 8 )
             {
                 Vec_IntGrow( vLevel, Vec_IntSize(p->vCover) );
                 Vec_IntAppend( vLevel, p->vCover );
                 if ( fCompl )
                     vLevel->nCap ^= (1<<16); // hack to remember complemented attribute
             }
         }
         assert( Vec_WecSize(p->vIsops[v]) == Vec_MemEntryNum(p->vTtMem[v]) );
     }
 }

int If_DsdManCheckDec	(	If_DsdMan_t *	p,
		int	iDsd
	)

Definition at line 185 of file ifDsd.c.

 {
     return If_DsdVecObjMark( &p->vObjs, Abc_Lit2Var(iDsd) );
 }

unsigned If_DsdManCheckXY	(	If_DsdMan_t *	p,
		int	iDsd,
		int	LutSize,
		int	fDerive,
		unsigned	uMaskNot,
		int	fHighEffort,
		int	fVerbose
	)

Definition at line 1986 of file ifDsd.c.

 {
     unsigned uSet = If_DsdManCheckXY_int( p, iDsd, LutSize, fDerive, uMaskNot, fVerbose );
     if ( uSet == 0 && fHighEffort )
     {
 //        abctime clk = Abc_Clock();
         int nVars = If_DsdVecLitSuppSize( &p->vObjs, iDsd );
         word * pRes = If_DsdManComputeTruth( p, iDsd, NULL );
         uSet = If_ManSatCheckXYall( p->pSat, LutSize, pRes, nVars, p->vTemp1 );
         if ( uSet )
         {
 //            If_DsdManPrintOne( stdout, p, Abc_Lit2Var(iDsd), NULL, 1 );
 //            Dau_DecPrintSet( uSet, nVars, 1 );
         }
 //        p->timeCheck2 += Abc_Clock() - clk;
     }
     return uSet;
 }

void If_DsdManCleanMarks	(	If_DsdMan_t *	p,
		int	fVerbose
	)

Definition at line 1224 of file ifDsd.c.

 {
     If_DsdObj_t * pObj; 
     int i;
     ABC_FREE( p->pCellStr );
     Vec_WrdFreeP( &p->vPerms );
     If_DsdVecForEachObj( &p->vObjs, pObj, i )
         pObj->fMark = 0;
 }

void If_DsdManCleanOccur	(	If_DsdMan_t *	p,
		int	fVerbose
	)

Definition at line 1217 of file ifDsd.c.

 {
     If_DsdObj_t * pObj; 
     int i;
     If_DsdVecForEachObj( &p->vObjs, pObj, i )
         pObj->Count = 0;
 }

int If_DsdManCompute	(	If_DsdMan_t *	p,
		word *	pTruth,
		int	nLeaves,
		unsigned char *	pPerm,
		char *	pLutStruct
	)

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

Synopsis [Add the function to the DSD manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 2032 of file ifDsd.c.

 {
     word pCopy[DAU_MAX_WORD], * pRes;
     char pDsd[DAU_MAX_STR];
     int iDsd, nSizeNonDec, nSupp = 0;
     int nWords = Abc_TtWordNum(nLeaves);
 //    abctime clk = 0;
     assert( nLeaves <= DAU_MAX_VAR );
     Abc_TtCopy( pCopy, pTruth, nWords, 0 );
 //clk = Abc_Clock();
     nSizeNonDec = Dau_DsdDecompose( pCopy, nLeaves, 0, 1, pDsd );
 //p->timeDsd += Abc_Clock() - clk;
     if ( nSizeNonDec > 0 )
         Abc_TtStretch6( pCopy, nSizeNonDec, p->nVars );
     memset( pPerm, 0xFF, nLeaves );
 //clk = Abc_Clock();
     iDsd = If_DsdManAddDsd( p, pDsd, pCopy, pPerm, &nSupp );
 //p->timeCanon += Abc_Clock() - clk;
     assert( nSupp == nLeaves );
     // verify the result
 //clk = Abc_Clock();
     pRes = If_DsdManComputeTruth( p, iDsd, pPerm );
 //p->timeVerify += Abc_Clock() - clk;
     if ( !Abc_TtEqual(pRes, pTruth, nWords) )
     {
 //        If_DsdManPrint( p, NULL );
         printf( "\n" );
         printf( "Verification failed!\n" );
         printf( "%s\n", pDsd );
         Dau_DsdPrintFromTruth( pTruth, nLeaves );
         Dau_DsdPrintFromTruth( pRes, nLeaves );
         If_DsdManPrintOne( stdout, p, Abc_Lit2Var(iDsd), pPerm, 1 );
         printf( "\n" );
     }
     If_DsdVecObjIncRef( &p->vObjs, Abc_Lit2Var(iDsd) );
     assert( If_DsdVecLitSuppSize(&p->vObjs, iDsd) == nLeaves );
     return iDsd;
 }

char* If_DsdManFileName ( If_DsdMan_t * p )

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 161 of file ifDsd.c.

 {
     return p->pStore;
 }

If_DsdMan_t* If_DsdManFilter	(	If_DsdMan_t *	p,
		int	Limit
	)

Definition at line 1263 of file ifDsd.c.

 {
     If_DsdMan_t * pNew = If_DsdManAlloc( p->nVars, p->LutSize );
     If_DsdObj_t * pObj; 
     Vec_Int_t * vMap;
     int i;
     vMap = Vec_IntStartFull( Vec_PtrSize(&p->vObjs) );
     Vec_IntWriteEntry( vMap, 0, 0 );
     Vec_IntWriteEntry( vMap, 1, 1 );
     If_DsdVecForEachNode( &p->vObjs, pObj, i )
         if ( (int)pObj->Count >= Limit )
             If_DsdManFilter_rec( pNew, p, i, vMap );
     Vec_IntFree( vMap );
     return pNew;
 }

void If_DsdManFree	(	If_DsdMan_t *	p,
		int	fVerbose
	)

Definition at line 316 of file ifDsd.c.

 {
     int v;
 //    If_DsdManDumpDsd( p );
     if ( fVerbose )
         If_DsdManPrint( p, NULL, 0, 0, 0, 0, 0 );
     if ( fVerbose )
     {
         char FileName[10];
         for ( v = 3; v <= p->nVars; v++ )
         {
             sprintf( FileName, "dumpdsd%02d", v );
             Vec_MemDumpTruthTables( p->vTtMem[v], FileName, v );
         }
     }
     for ( v = 2; v < p->nVars; v++ )
         ABC_FREE( p->pSched[v] );
     for ( v = 3; v <= p->nVars; v++ )
     {
         Vec_MemHashFree( p->vTtMem[v] );
         Vec_MemFree( p->vTtMem[v] );
         Vec_VecFree( (Vec_Vec_t *)(p->vTtDecs[v]) );
         if ( p->vIsops[v] )
             Vec_WecFree( p->vIsops[v] );
     }
     Vec_WrdFreeP( &p->vPerms );
     Vec_IntFreeP( &p->vTemp1 );
     Vec_IntFreeP( &p->vTemp2 );
     ABC_FREE( p->vObjs.pArray );
     ABC_FREE( p->vNexts.pArray );
     ABC_FREE( p->vTruths.pArray );
     Mem_FlexStop( p->pMem, 0 );
     Gia_ManStopP( &p->pTtGia );
     Vec_IntFreeP( &p->vCover );
     If_ManSatUnbuild( p->pSat );
     ABC_FREE( p->pCellStr );
     ABC_FREE( p->pStore );
     ABC_FREE( p->pBins );
     ABC_FREE( p );
 }

char* If_DsdManGetCellStr ( If_DsdMan_t * p )

Definition at line 203 of file ifDsd.c.

 {
     return p->pCellStr;
 }

word If_DsdManGetFuncPerm	(	If_DsdMan_t *	p,
		int	iDsd
	)

Definition at line 199 of file ifDsd.c.

 {
     return p->vPerms ? Vec_WrdEntry(p->vPerms, Abc_Lit2Var(iDsd)) : 0;
 }

void If_DsdManInvertMarks	(	If_DsdMan_t *	p,
		int	fVerbose
	)

Definition at line 1233 of file ifDsd.c.

 {
     If_DsdObj_t * pObj; 
     int i;
     ABC_FREE( p->pCellStr );
     Vec_WrdFreeP( &p->vPerms );
     If_DsdVecForEachObj( &p->vObjs, pObj, i )
         pObj->fMark = !pObj->fMark;
 }

If_DsdMan_t* If_DsdManLoad ( char * pFileName )

Definition at line 1086 of file ifDsd.c.

 {
     If_DsdMan_t * p;
     If_DsdObj_t * pObj; 
     Vec_Int_t * vSets;
     char pBuffer[10];
     unsigned * pSpot;
     word * pTruth;
     int i, v, Num, Num2, RetValue;
     FILE * pFile = fopen( pFileName, "rb" );
     if ( pFile == NULL )
     {
         printf( "Reading DSD manager file \"%s\" has failed.\n", pFileName );
         return NULL;
     }
     RetValue = fread( pBuffer, 4, 1, pFile );
     if ( pBuffer[0] != 'd' && pBuffer[1] != 's' && pBuffer[2] != 'd' && pBuffer[3] != '0' )
     {
         printf( "Unrecognized format of file \"%s\".\n", pFileName );
         return NULL;
     }
     RetValue = fread( &Num, 4, 1, pFile );
     p = If_DsdManAlloc( Num, 0 );
     ABC_FREE( p->pStore );
     p->pStore = Abc_UtilStrsav( pFileName );
     RetValue = fread( &Num, 4, 1, pFile );
     p->LutSize = Num;
     p->pSat  = If_ManSatBuildXY( p->LutSize );
     RetValue = fread( &Num, 4, 1, pFile );
     assert( Num >= 2 );
     Vec_PtrFillExtra( &p->vObjs, Num, NULL );
     Vec_IntFill( &p->vNexts, Num, 0 );
     Vec_IntFill( &p->vTruths, Num, -1 );
     p->nBins = Abc_PrimeCudd( 2*Num );
     p->pBins = ABC_REALLOC( unsigned, p->pBins, p->nBins );
     memset( p->pBins, 0, sizeof(unsigned) * p->nBins );
     for ( i = 2; i < Vec_PtrSize(&p->vObjs); i++ )
     {
         RetValue = fread( &Num, 4, 1, pFile );
         pObj = (If_DsdObj_t *)Mem_FlexEntryFetch( p->pMem, sizeof(word) * Num );
         RetValue = fread( pObj, sizeof(word)*Num, 1, pFile );
         Vec_PtrWriteEntry( &p->vObjs, i, pObj );
         if ( pObj->Type == IF_DSD_PRIME )
         {
             RetValue = fread( &Num, 4, 1, pFile );
             Vec_IntWriteEntry( &p->vTruths, i, Num );
         }
         pSpot = If_DsdObjHashLookup( p, pObj->Type, (int *)pObj->pFans, pObj->nFans, If_DsdObjTruthId(p, pObj) );
         assert( *pSpot == 0 );
         *pSpot = pObj->Id;
     }
     assert( p->nUniqueMisses == Vec_PtrSize(&p->vObjs) - 2 );
     p->nUniqueMisses = 0;
     pTruth = ABC_ALLOC( word, p->nWords );
     for ( v = 3; v <= p->nVars; v++ )
     {
         int nBytes = sizeof(word)*Vec_MemEntrySize(p->vTtMem[v]);
         RetValue = fread( &Num, 4, 1, pFile );
         for ( i = 0; i < Num; i++ )
         {
             RetValue = fread( pTruth, nBytes, 1, pFile );
             Vec_MemHashInsert( p->vTtMem[v], pTruth );
         }
         assert( Num == Vec_MemEntryNum(p->vTtMem[v]) );
         RetValue = fread( &Num2, 4, 1, pFile );
         for ( i = 0; i < Num2; i++ )
         {
             RetValue = fread( &Num, 4, 1, pFile );
             vSets = Vec_IntAlloc( Num );
             RetValue = fread( Vec_IntArray(vSets), sizeof(int)*Num, 1, pFile );
             vSets->nSize = Num;
             Vec_PtrPush( p->vTtDecs[v], vSets );
         }
         assert( Num2 == Vec_PtrSize(p->vTtDecs[v]) ); 
     }
     ABC_FREE( pTruth );
     RetValue = fread( &Num, 4, 1, pFile );
     if ( RetValue && Num )
     {
         p->vPerms = Vec_WrdStart( Num );
         RetValue = fread( Vec_WrdArray(p->vPerms), sizeof(word)*Num, 1, pFile );
     }
     RetValue = fread( &Num, 4, 1, pFile );
     if ( RetValue && Num )
     {
         p->pCellStr = ABC_CALLOC( char, Num + 1 );
         RetValue = fread( p->pCellStr, sizeof(char)*Num, 1, pFile );
     }
     fclose( pFile );
     return p;
 }

int If_DsdManLutSize ( If_DsdMan_t * p )

Definition at line 173 of file ifDsd.c.

 {
     return p->LutSize;
 }

void If_DsdManMerge	(	If_DsdMan_t *	p,
		If_DsdMan_t *	pNew
	)

Definition at line 1177 of file ifDsd.c.

 {
     If_DsdObj_t * pObj; 
     Vec_Int_t * vMap;
     int pFanins[DAU_MAX_VAR];
     int i, k, iFanin, Id;
     if ( p->nVars < pNew->nVars )
     {
         printf( "The number of variables should be the same or smaller.\n" );
         return;
     }
     if ( p->LutSize != pNew->LutSize )
     {
         printf( "LUT size should be the same.\n" );
         return;
     }
     if ( If_DsdManHasMarks(p) != If_DsdManHasMarks(pNew) )
         printf( "Warning! Old manager has %smarks while new manager has %smarks.\n", 
             If_DsdManHasMarks(p) ? "" : "no ", If_DsdManHasMarks(pNew) ? "" : "no " );
     vMap = Vec_IntAlloc( Vec_PtrSize(&pNew->vObjs) );
     Vec_IntPush( vMap, 0 );
     Vec_IntPush( vMap, 1 );
     if ( p->vPerms && pNew->vPerms )
         Vec_WrdFillExtra( p->vPerms, Vec_PtrSize(&p->vObjs) + Vec_PtrSize(&pNew->vObjs), 0 );
     If_DsdVecForEachNode( &pNew->vObjs, pObj, i )
     {
         If_DsdObjForEachFaninLit( &pNew->vObjs, pObj, iFanin, k )
             pFanins[k] = Abc_Lit2LitV( Vec_IntArray(vMap), iFanin );
         Id = If_DsdObjFindOrAdd( p, pObj->Type, pFanins, pObj->nFans, pObj->Type == IF_DSD_PRIME ? If_DsdObjTruth(pNew, pObj) : NULL );
         if ( pObj->fMark )
             If_DsdVecObjSetMark( &p->vObjs, Id );
         if ( p->vPerms && pNew->vPerms && i < Vec_WrdSize(pNew->vPerms) )
             Vec_WrdFillExtra( p->vPerms, Id, Vec_WrdEntry(pNew->vPerms, i) );
         Vec_IntPush( vMap, Id );
     }
     assert( Vec_IntSize(vMap) == Vec_PtrSize(&pNew->vObjs) );
     Vec_IntFree( vMap );
     if ( p->vPerms && pNew->vPerms )
         Vec_WrdShrink( p->vPerms, Vec_PtrSize(&p->vObjs) );
 }

int If_DsdManObjNum ( If_DsdMan_t * p )

Definition at line 169 of file ifDsd.c.

 {
     return Vec_PtrSize( &p->vObjs );
 }

void If_DsdManPrint	(	If_DsdMan_t *	p,
		char *	pFileName,
		int	Number,
		int	Support,
		int	fOccurs,
		int	fTtDump,
		int	fVerbose
	)

Definition at line 684 of file ifDsd.c.

 {
     If_DsdObj_t * pObj;
     Vec_Int_t * vStructs, * vCounts;
     int CountUsed = 0, CountNonDsd = 0, CountNonDsdStr = 0, CountMarked = 0, CountPrime = 0;
     int i, v, * pPerm, DsdMax = 0, MemSizeTTs = 0, MemSizeDecs = 0;
     FILE * pFile;
     pFile = pFileName ? fopen( pFileName, "wb" ) : stdout;
     if ( pFileName && pFile == NULL )
     {
         printf( "cannot open output file\n" );
         return;
     }
     if ( fVerbose )
     {
         fprintf( pFile, "*****  NOTATIONS USED BELOW  *****\n" );
         fprintf( pFile, "Support -- the support size\n" );
         fprintf( pFile, "Obj     -- the number of nodes in the DSD manager for each support size\n" );
         fprintf( pFile, "           (the constant node and the primary input node have no support)\n" );
         fprintf( pFile, "ObjNDSD -- the number of prime nodes (that is, nodes whose function has no DSD)\n" );
         fprintf( pFile, "           (percentage is relative to the number of all nodes of that size)\n" );
         fprintf( pFile, "NPNNDSD -- the number of different NPN classes of prime nodes\n" );
         fprintf( pFile, "           (Each NPN class may appear more than once. For example: F1 = 17(ab(cd))\n" ); 
         fprintf( pFile, "           and F2 = 17(ab[cd]) both have prime majority node (hex TT is 17),\n" ); 
         fprintf( pFile, "           but in one case the majority node is fed by AND, and in another by XOR.\n" );
         fprintf( pFile, "           These two majority nodes are different nodes in the DSD manager\n" );
         fprintf( pFile, "Str     -- the number of structures for each support size\n" );
         fprintf( pFile, "           (each structure is composed of one or more nodes)\n" );
         fprintf( pFile, "StrNDSD -- the number of DSD structures containing at least one prime node\n" );
         fprintf( pFile, "Marked  -- the number of DSD structures matchable with the LUT structure (say, \"44\")\n" );
     }
     If_DsdVecForEachObj( &p->vObjs, pObj, i )
     {
         if ( If_DsdObjType(pObj) == IF_DSD_PRIME )
             DsdMax = Abc_MaxInt( DsdMax, pObj->nFans ); 
         CountPrime += If_DsdObjType(pObj) == IF_DSD_PRIME;
         CountNonDsdStr += If_DsdManCheckNonDec_rec( p, pObj->Id );
         CountUsed += ( If_DsdVecObjRef(&p->vObjs, pObj->Id) > 0 );
         CountMarked += If_DsdVecObjMark( &p->vObjs, i );
     }
     for ( v = 3; v <= p->nVars; v++ )
     {
         CountNonDsd += Vec_MemEntryNum(p->vTtMem[v]);
         MemSizeTTs += Vec_MemEntrySize(p->vTtMem[v]) * Vec_MemEntryNum(p->vTtMem[v]);
         MemSizeDecs += (int)Vec_VecMemoryInt((Vec_Vec_t *)(p->vTtDecs[v]));
     }
     If_DsdManPrintDistrib( p );
     printf( "Number of inputs = %d.  LUT size = %d.  Marks = %s.  NewAsUseless = %s.  Bookmark = %d.\n", 
         p->nVars, p->LutSize, If_DsdManHasMarks(p)? "yes" : "no", p->fNewAsUseless? "yes" : "no", p->nObjsPrev );
     if ( p->pCellStr )
         printf( "Symbolic cell description: %s\n", p->pCellStr );
     if ( p->pTtGia )
     fprintf( pFile, "Non-DSD AIG nodes          = %8d\n", Gia_ManAndNum(p->pTtGia) );
     fprintf( pFile, "Unique table misses        = %8d\n", p->nUniqueMisses );
     fprintf( pFile, "Unique table hits          = %8d\n", p->nUniqueHits );
     fprintf( pFile, "Memory used for objects    = %8.2f MB.\n", 1.0*Mem_FlexReadMemUsage(p->pMem)/(1<<20) );
     fprintf( pFile, "Memory used for functions  = %8.2f MB.\n", 8.0*(MemSizeTTs+sizeof(int)*Vec_IntCap(&p->vTruths))/(1<<20) );
     fprintf( pFile, "Memory used for hash table = %8.2f MB.\n", 1.0*sizeof(int)*(p->nBins+Vec_IntCap(&p->vNexts))/(1<<20) );
     fprintf( pFile, "Memory used for bound sets = %8.2f MB.\n", 1.0*MemSizeDecs/(1<<20) );
     fprintf( pFile, "Memory used for array      = %8.2f MB.\n", 1.0*sizeof(void *)*Vec_PtrCap(&p->vObjs)/(1<<20) );
     if ( p->pTtGia )
     fprintf( pFile, "Memory used for AIG        = %8.2f MB.\n", 8.0*Gia_ManAndNum(p->pTtGia)/(1<<20) );
     if ( p->timeDsd )
     {
         Abc_PrintTime( 1, "Time DSD   ", p->timeDsd    );
         Abc_PrintTime( 1, "Time canon ", p->timeCanon-p->timeCheck  );
         Abc_PrintTime( 1, "Time check ", p->timeCheck  );
         Abc_PrintTime( 1, "Time check2", p->timeCheck2 );
         Abc_PrintTime( 1, "Time verify", p->timeVerify );
     }
     if ( fOccurs )
         If_DsdManPrintOccurs( stdout, p );
 //    If_DsdManHashProfile( p );
     if ( fTtDump )
         If_DsdManDumpDsd( p, Support );
     if ( fTtDump )
         If_DsdManDumpAll( p, Support );
 //    If_DsdManPrintDecs( stdout, p );
     if ( !fVerbose )
         return;
     vStructs = Vec_IntAlloc( 1000 );
     vCounts  = Vec_IntAlloc( 1000 );
     If_DsdVecForEachObj( &p->vObjs, pObj, i )
     {
         if ( Number && i % Number )
             continue;
         if ( Support && Support != If_DsdObjSuppSize(pObj) )
             continue;
         Vec_IntPush( vStructs, i );
         Vec_IntPush( vCounts, -(int)pObj->Count );
 //        If_DsdManPrintOne( pFile, p, pObj->Id, NULL, 1 );
     }
 //    fprintf( pFile, "\n" );
     pPerm = Abc_MergeSortCost( Vec_IntArray(vCounts), Vec_IntSize(vCounts) );
     for ( i = 0; i < Abc_MinInt(Vec_IntSize(vCounts), 20); i++ )
     {
         printf( "%2d : ", i+1 );
         pObj = If_DsdVecObj( &p->vObjs, Vec_IntEntry(vStructs, pPerm[i]) );
         If_DsdManPrintOne( pFile, p, pObj->Id, NULL, 1 );
     }
     ABC_FREE( pPerm );
     Vec_IntFree( vStructs );
     Vec_IntFree( vCounts );
     if ( pFileName )
         fclose( pFile );
 }

int If_DsdManReadMark	(	If_DsdMan_t *	p,
		int	iDsd
	)

Definition at line 189 of file ifDsd.c.

 {
     return If_DsdVecObjMark( &p->vObjs, Abc_Lit2Var(iDsd) );
 }

void If_DsdManSave	(	If_DsdMan_t *	p,
		char *	pFileName
	)

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

Synopsis [Saving/loading DSD manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 1032 of file ifDsd.c.

 {
     If_DsdObj_t * pObj; 
     Vec_Int_t * vSets;
     char * pBuffer = "dsd0";
     word * pTruth; 
     int i, v, Num;
     FILE * pFile = fopen( pFileName ? pFileName : p->pStore, "wb" );
     if ( pFile == NULL )
     {
         printf( "Writing DSD manager file \"%s\" has failed.\n", pFileName ? pFileName : p->pStore );
         return;
     }
     fwrite( pBuffer, 4, 1, pFile );
     Num = p->nVars;
     fwrite( &Num, 4, 1, pFile );
     Num = p->LutSize;
     fwrite( &Num, 4, 1, pFile );
     Num = Vec_PtrSize(&p->vObjs);
     fwrite( &Num, 4, 1, pFile );
     Vec_PtrForEachEntryStart( If_DsdObj_t *, &p->vObjs, pObj, i, 2 )
     {
         Num = If_DsdObjWordNum( pObj->nFans );
         fwrite( &Num, 4, 1, pFile );
         fwrite( pObj, sizeof(word)*Num, 1, pFile );
         if ( pObj->Type == IF_DSD_PRIME )
             fwrite( Vec_IntEntryP(&p->vTruths, i), 4, 1, pFile );
     }
     for ( v = 3; v <= p->nVars; v++ )
     {
         int nBytes = sizeof(word)*Vec_MemEntrySize(p->vTtMem[v]);
         Num = Vec_MemEntryNum(p->vTtMem[v]);
         fwrite( &Num, 4, 1, pFile );
         Vec_MemForEachEntry( p->vTtMem[v], pTruth, i )
             fwrite( pTruth, nBytes, 1, pFile );
         Num = Vec_PtrSize(p->vTtDecs[v]);
         fwrite( &Num, 4, 1, pFile );
         Vec_PtrForEachEntry( Vec_Int_t *, p->vTtDecs[v], vSets, i )
         {
             Num = Vec_IntSize(vSets);
             fwrite( &Num, 4, 1, pFile );
             fwrite( Vec_IntArray(vSets), sizeof(int)*Num, 1, pFile );
         }
     }
     Num = p->vPerms ? Vec_WrdSize(p->vPerms) : 0;
     fwrite( &Num, 4, 1, pFile );
     if ( Num )
         fwrite( Vec_WrdArray(p->vPerms), sizeof(word)*Num, 1, pFile );
     Num = p->pCellStr ? strlen(p->pCellStr) : 0;
     fwrite( &Num, 4, 1, pFile );
     if ( Num )
         fwrite( p->pCellStr, sizeof(char)*Num, 1, pFile );
     fclose( pFile );
 }

void If_DsdManSetLutSize	(	If_DsdMan_t *	p,
		int	nLutSize
	)

Definition at line 177 of file ifDsd.c.

 {
     p->LutSize = nLutSize;
 }

void If_DsdManSetNewAsUseless ( If_DsdMan_t * p )

Definition at line 193 of file ifDsd.c.

 {
     if ( p->nObjsPrev == 0 )
         p->nObjsPrev = If_DsdManObjNum(p);
     p->fNewAsUseless = 1;
 }

int If_DsdManSuppSize	(	If_DsdMan_t *	p,
		int	iDsd
	)

Definition at line 181 of file ifDsd.c.

 {
     return If_DsdVecLitSuppSize( &p->vObjs, iDsd );
 }

void If_DsdManTune	(	If_DsdMan_t *	p,
		int	LutSize,
		int	fFast,
		int	fAdd,
		int	fSpec,
		int	fVerbose
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2377 of file ifDsd.c.

 {
     ProgressBar * pProgress = NULL;
     sat_solver * pSat = NULL;
     If_DsdObj_t * pObj;
     Vec_Int_t * vLits;
     int i, Value, nVars;
     word * pTruth;
     if ( !fAdd || !LutSize )
         If_DsdVecForEachObj( &p->vObjs, pObj, i )
             pObj->fMark = 0;
     if ( LutSize == 0 )
         return;
     vLits = Vec_IntAlloc( 1000 );
     pSat = (sat_solver *)If_ManSatBuildXY( LutSize );
     pProgress = Extra_ProgressBarStart( stdout, Vec_PtrSize(&p->vObjs) );
     If_DsdVecForEachObj( &p->vObjs, pObj, i )
     {
         Extra_ProgressBarUpdate( pProgress, i, NULL );
         nVars = If_DsdObjSuppSize(pObj);
         if ( nVars <= LutSize )
             continue;
         if ( fAdd && !pObj->fMark )
             continue;
         pObj->fMark = 0;
         if ( If_DsdManCheckXY(p, Abc_Var2Lit(i, 0), LutSize, 0, 0, 0, 0) )
             continue;
         if ( fFast )
             Value = 0;
         else
         {
             pTruth = If_DsdManComputeTruth( p, Abc_Var2Lit(i, 0), NULL );
             Value = If_ManSatCheckXYall( pSat, LutSize, pTruth, nVars, vLits );
         }
         if ( Value )
             continue;
         If_DsdVecObjSetMark( &p->vObjs, i );
     }
     Extra_ProgressBarStop( pProgress );
     If_ManSatUnbuild( pSat );
     Vec_IntFree( vLits );
     if ( fVerbose )
         If_DsdManPrintDistrib( p );
 }

int If_DsdManVarNum ( If_DsdMan_t * p )

Definition at line 165 of file ifDsd.c.

 {
     return p->nVars;
 }

static int If_IsComplement ( If_Obj_t * p )

inlinestatic

Definition at line 358 of file if.h.

358 { return (int )(((ABC_PTRUINT_T)p) & 01); }

void If_LibBoxAdd	(	If_LibBox_t *	p,
		If_Box_t *	pBox
	)

Definition at line 136 of file ifLibBox.c.

 {
     if ( pBox->Id >= Vec_PtrSize(p->vBoxes) )
         Vec_PtrFillExtra( p->vBoxes, 2 * pBox->Id + 10, NULL );
     assert( Vec_PtrEntry( p->vBoxes, pBox->Id ) == NULL );
     Vec_PtrWriteEntry( p->vBoxes, pBox->Id, pBox );
 }

If_Box_t* If_LibBoxFindBox	(	If_LibBox_t *	p,
		char *	pName
	)

Definition at line 125 of file ifLibBox.c.

 {
     If_Box_t * pBox;
     int i;
     if ( p == NULL )
         return NULL;
     If_LibBoxForEachBox( p, pBox, i )
         if ( !strcmp(pBox->pName, pName) )
             return pBox;
     return NULL;
 }

void If_LibBoxFree ( If_LibBox_t * p )

Definition at line 98 of file ifLibBox.c.

 {
     If_Box_t * pBox;
     int i;
     if ( p == NULL )
         return;
     If_LibBoxForEachBox( p, pBox, i )
         If_BoxFree( pBox );
     Vec_PtrFree( p->vBoxes );
     ABC_FREE( p );
 }

int If_LibBoxLoad ( char * pFileName )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 375 of file ifLibBox.c.

 {
     FILE * pFile;
     If_LibBox_t * pLib;
     char * pFileNameOther;
     // check if library can be read
     pFileNameOther = Extra_FileNameGenericAppend( pFileName, ".cdl" );
     pFile = fopen( pFileNameOther, "r" );
     if ( pFile == NULL )
         return 0;
     fclose( pFile );
     // read library
     pLib = If_LibBoxRead2( pFileNameOther );
     // replace the current library
     If_LibBoxFree( (If_LibBox_t *)Abc_FrameReadLibBox() );
     Abc_FrameSetLibBox( pLib );
     return 1;
 }

void If_LibBoxPrint	(	FILE *	pFile,
		If_LibBox_t *	p
	)

Definition at line 334 of file ifLibBox.c.

 {
     If_Box_t * pBox;
     int i, j, k;
     fprintf( pFile, "# Box library written by ABC on %s.\n", Extra_TimeStamp() );
     fprintf( pFile, "# <Name> <ID> <Type> <I> <O>\n" );
     If_LibBoxForEachBox( p, pBox, i )
     {
         fprintf( pFile, "%s %d %d %d %d\n", pBox->pName, pBox->Id, !pBox->fBlack, pBox->nPis, pBox->nPos );
         for ( j = 0; j < pBox->nPos; j++, printf("\n") )
             for ( k = 0; k < pBox->nPis; k++ )
                 if ( pBox->pDelays[j * pBox->nPis + k] == -ABC_INFINITY )
                     fprintf( pFile, "    - " );
                 else
                     fprintf( pFile, "%5d ", pBox->pDelays[j * pBox->nPis + k] );
     }
 }

If_LibBox_t* If_LibBoxRead ( char * pFileName )

Definition at line 273 of file ifLibBox.c.

 {
     FILE * pFile;
     If_LibBox_t * p;
     If_Box_t * pBox;
     char * pToken, * pName;
     int i, Id, fBlack, nPis, nPos;
     pFile = fopen( pFileName, "rb" );
     if ( pFile == NULL )
     {
         printf( "Cannot open file \"%s\".\n", pFileName );
         return NULL;
     }
     // get the library name
     pToken = If_LibBoxGetToken( pFile );
     if ( pToken == NULL )
     {
         fclose( pFile );
         printf( "Cannot read library name from file \"%s\".\n", pFileName );
         return NULL;
     }
     if ( pToken[0] == '.' )    
     {
         fclose( pFile );
         printf( "Wrong box format. Please try \"read_box -e\".\n" );
         return NULL;
     }
        
     // create library
     p = If_LibBoxStart();
     while ( pToken )
     {
         // save name
         pName  = Abc_UtilStrsav(pToken);
         // save ID
         pToken = If_LibBoxGetToken( pFile );
         Id     = atoi( pToken );
         // save white/black
         pToken = If_LibBoxGetToken( pFile );
         fBlack = !atoi( pToken );
         // save PIs
         pToken = If_LibBoxGetToken( pFile );
         nPis   = atoi( pToken );
         // save POs
         pToken = If_LibBoxGetToken( pFile );
         nPos   = atoi( pToken );
         // create box
         pBox   = If_BoxStart( pName, Id, nPis, nPos, 0, fBlack, 0 );
         If_LibBoxAdd( p, pBox );
         // read the table
         for ( i = 0; i < nPis * nPos; i++ )
         {
             pToken = If_LibBoxGetToken( pFile );
             pBox->pDelays[i] = (pToken[0] == '-') ? -ABC_INFINITY : atoi(pToken);
         }
         // extract next name
         pToken = If_LibBoxGetToken( pFile );
     }
     fclose( pFile );
     return p;
 }

If_LibBox_t* If_LibBoxRead2 ( char * pFileName )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 155 of file ifLibBox.c.

 {
     int nSize = 100000;
     char * pBuffer;
     FILE * pFile;
     If_LibBox_t * p = NULL;
     If_Box_t * pBox = NULL;
     char * pToken, * pName;
     int fSeq, fBlack, fOuter;
     int i, Id, nPis, nPos;
     pFile = fopen( pFileName, "rb" );
     if ( pFile == NULL )
     {
         printf( "Cannot open file \"%s\".\n", pFileName );
         return NULL;
     }
     // read lines
     nPis = nPos = 0;
     pBuffer = ABC_ALLOC( char, nSize );
     while ( fgets( pBuffer, nSize, pFile ) )
     {
         pToken = strtok( pBuffer, " \n\r\t" );
         if ( pToken == NULL )
             continue;
         if ( pToken[0] == '.' )
         {
             if ( !strcmp(pToken, ".box") )
             {
                 // save ID
                 pToken = strtok( NULL, " \n\r\t" );
                 Id     = atoi( pToken );
                 // save name
                 pToken = strtok( NULL, " \n\r\t" );
                 pName  = Abc_UtilStrsav(pToken);
                 // save PIs
                 pToken = strtok( NULL, " \n\r\t" );
                 nPis   = atoi( pToken );
                 // save POs
                 pToken = strtok( NULL, " \n\r\t" );
                 nPos   = atoi( pToken );
                 // save attributes
                 fSeq = fBlack = fOuter = 0;
                 pToken = strtok( NULL, " \n\r\t" );
                 while ( pToken )
                 {
                     if ( !strcmp(pToken, "seq") )
                         fSeq = 1;
                     else if ( !strcmp(pToken, "black") )
                         fBlack = 1;
                     else if ( !strcmp(pToken, "outer") )
                         fOuter = 1;
                     else assert( !strcmp(pToken, "comb") || !strcmp(pToken, "white") || !strcmp(pToken, "inner") );
                     pToken = strtok( NULL, " \n\r\t" );
                 }
                 // create library
                 if ( p == NULL )
                     p = If_LibBoxStart();
                 // create box
                 pBox = If_BoxStart( pName, Id, nPis, nPos, fSeq, fBlack, fOuter );
                 If_LibBoxAdd( p, pBox );
             }
             continue;
         }
         // read the table
         assert( nPis > 0 && nPos > 0 );
         for ( i = 0; i < nPis * nPos; i++ )
         {
             while ( pToken == NULL )
             {
                 if ( fgets( pBuffer, nSize, pFile ) == NULL )
                 { printf( "The table does not have enough entries.\n" ); fflush(stdout); assert( 0 ); }
                 pToken = strtok( pBuffer, " \n\r\t" );
             }
             pBox->pDelays[i] = (pToken[0] == '-') ? -1 : atoi(pToken);
             pToken = strtok( NULL, " \n\r\t" );
         }
         pBox = NULL;
     }
     ABC_FREE( pBuffer );
     fclose( pFile );
     return p;
 }

If_Box_t* If_LibBoxReadBox	(	If_LibBox_t *	p,
		int	Id
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 121 of file ifLibBox.c.

 {
     return (If_Box_t *)Vec_PtrEntry( p->vBoxes, Id );
 }

If_LibBox_t* If_LibBoxStart ( )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 86 of file ifLibBox.c.

 {
     If_LibBox_t * p;
     p = ABC_CALLOC( If_LibBox_t, 1 );
     p->vBoxes = Vec_PtrAlloc( 100 );
     return p;
 }

void If_LibBoxWrite	(	char *	pFileName,
		If_LibBox_t *	p
	)

Definition at line 351 of file ifLibBox.c.

 {
     FILE * pFile;
     pFile = fopen( pFileName, "wb" );
     if ( pFile == NULL )
     {
         printf( "Cannot open file \"%s\".\n", pFileName );
         return;
     }
     If_LibBoxPrint( pFile, p );
     fclose( pFile );
 }

int If_LibLutDelaysAreDifferent ( If_LibLut_t * pLutLib )

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

Synopsis [Returns 1 if the delays are discrete.]

Description []

SideEffects []

SeeAlso []

Definition at line 248 of file ifLibLut.c.

 {
     int i, k;
     float Delay = pLutLib->pLutDelays[1][0];
     if ( pLutLib->fVarPinDelays )
     {
         for ( i = 2; i <= pLutLib->LutMax; i++ )
         for ( k = 0; k < i; k++ )
             if ( pLutLib->pLutDelays[i][k] != Delay )
                 return 1;
     }
     else
     {
         for ( i = 2; i <= pLutLib->LutMax; i++ )
             if ( pLutLib->pLutDelays[i][0] != Delay )
                 return 1;
     }
     return 0;
 }

int If_LibLutDelaysAreDiscrete ( If_LibLut_t * pLutLib )

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

Synopsis [Returns 1 if the delays are discrete.]

Description []

SideEffects []

SeeAlso []

Definition at line 224 of file ifLibLut.c.

 {
     float Delay;
     int i;
     for ( i = 1; i <= pLutLib->LutMax; i++ )
     {
         Delay = pLutLib->pLutDelays[i][0];
         if ( ((float)((int)Delay)) != Delay )
             return 0;
     }
     return 1;
 }

If_LibLut_t* If_LibLutDup ( If_LibLut_t * p )

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

Synopsis [Duplicates the LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 153 of file ifLibLut.c.

 {
     If_LibLut_t * pNew;
     pNew = ABC_ALLOC( If_LibLut_t, 1 );
     *pNew = *p;
     pNew->pName = If_UtilStrsav( pNew->pName );
     return pNew;
 }

float If_LibLutFastestPinDelay ( If_LibLut_t * p )

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

Synopsis [Gets the delay of the fastest pin.]

Description []

SideEffects []

SeeAlso []

Definition at line 319 of file ifLibLut.c.

 {
     return !p? 1.0 : p->pLutDelays[p->LutMax][0];
 }

void If_LibLutFree ( If_LibLut_t * pLutLib )

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

Synopsis [Frees the LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 173 of file ifLibLut.c.

 {
     if ( pLutLib == NULL )
         return;
     ABC_FREE( pLutLib->pName );
     ABC_FREE( pLutLib );
 }

void If_LibLutPrint ( If_LibLut_t * pLutLib )

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

Synopsis [Prints the LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 193 of file ifLibLut.c.

 {
     int i, k;
     Abc_Print( 1, "# The area/delay of k-variable LUTs:\n" );
     Abc_Print( 1, "# k    area     delay\n" );
     if ( pLutLib->fVarPinDelays )
     {
         for ( i = 1; i <= pLutLib->LutMax; i++ )
         {
             Abc_Print( 1, "%d   %7.2f  ", i, pLutLib->pLutAreas[i] );
             for ( k = 0; k < i; k++ )
                 Abc_Print( 1, " %7.2f", pLutLib->pLutDelays[i][k] );
             Abc_Print( 1, "\n" );
         }
     }
     else
         for ( i = 1; i <= pLutLib->LutMax; i++ )
             Abc_Print( 1, "%d   %7.2f   %7.2f\n", i, pLutLib->pLutAreas[i], pLutLib->pLutDelays[i][0] );
 }

If_LibLut_t* If_LibLutRead ( char * FileName )

FUNCTION DEFINITIONS ///.

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

Synopsis [Reads the description of LUTs from the LUT library file.]

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file ifLibLut.c.

 {
     char pBuffer[1000], * pToken;
     If_LibLut_t * p;
     FILE * pFile;
     int i, k;
 
     pFile = fopen( FileName, "r" );
     if ( pFile == NULL )
     {
         Abc_Print( -1, "Cannot open LUT library file \"%s\".\n", FileName );
         return NULL;
     }
 
     p = ABC_ALLOC( If_LibLut_t, 1 );
     memset( p, 0, sizeof(If_LibLut_t) );
     p->pName = If_UtilStrsav( FileName );
 
     i = 1;
     while ( fgets( pBuffer, 1000, pFile ) != NULL )
     {
         pToken = strtok( pBuffer, " \t\n" );
         if ( pToken == NULL )
             continue;
         if ( pToken[0] == '#' )
             continue;
         if ( i != atoi(pToken) )
         {
             Abc_Print( 1, "Error in the LUT library file \"%s\".\n", FileName );
             ABC_FREE( p->pName );
             ABC_FREE( p );
             return NULL;
         }
 
         // read area
         pToken = strtok( NULL, " \t\n" );
         p->pLutAreas[i] = (float)atof(pToken);
 
         // read delays
         k = 0;
         while ( (pToken = strtok( NULL, " \t\n" )) )
             p->pLutDelays[i][k++] = (float)atof(pToken);
 
         // check for out-of-bound
         if ( k > i )
         {
             ABC_FREE( p->pName );
             ABC_FREE( p );
             Abc_Print( 1, "LUT %d has too many pins (%d). Max allowed is %d.\n", i, k, i );
             return NULL;
         }
 
         // check if var delays are specified
         if ( k > 1 )
             p->fVarPinDelays = 1;
 
         if ( i == IF_MAX_LUTSIZE )
         {
             ABC_FREE( p->pName );
             ABC_FREE( p );
             Abc_Print( 1, "Skipping LUTs of size more than %d.\n", i );
             return NULL;
         }
         i++;
     }
     p->LutMax = i-1;
 
     // check the library
     if ( p->fVarPinDelays )
     {
         for ( i = 1; i <= p->LutMax; i++ )
             for ( k = 0; k < i; k++ )
             {
                 if ( p->pLutDelays[i][k] <= 0.0 )
                     Abc_Print( 0, "Pin %d of LUT %d has delay %f. Pin delays should be non-negative numbers. Technology mapping may not work correctly.\n", 
                         k, i, p->pLutDelays[i][k] );
                 if ( k && p->pLutDelays[i][k-1] > p->pLutDelays[i][k] )
                     Abc_Print( 0, "Pin %d of LUT %d has delay %f. Pin %d of LUT %d has delay %f. Pin delays should be in non-decreasing order. Technology mapping may not work correctly.\n", 
                         k-1, i, p->pLutDelays[i][k-1], 
                         k, i, p->pLutDelays[i][k] );
             }
     }
     else
     {
         for ( i = 1; i <= p->LutMax; i++ )
         {
             if ( p->pLutDelays[i][0] <= 0.0 )
                 Abc_Print( 0, "LUT %d has delay %f. Pin delays should be non-negative numbers. Technology mapping may not work correctly.\n", 
                     i, p->pLutDelays[i][0] );
         }
     }
 
     return p;
 }

If_LibLut_t* If_LibLutSetSimple ( int nLutSize )

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

Synopsis [Sets simple LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 279 of file ifLibLut.c.

 {
     If_LibLut_t s_LutLib10= { "lutlib",10, 0, {0,1,1,1,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib9 = { "lutlib", 9, 0, {0,1,1,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib8 = { "lutlib", 8, 0, {0,1,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib7 = { "lutlib", 7, 0, {0,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib6 = { "lutlib", 6, 0, {0,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib5 = { "lutlib", 5, 0, {0,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib4 = { "lutlib", 4, 0, {0,1,1,1,1}, {{0},{1},{1},{1},{1}} };
     If_LibLut_t s_LutLib3 = { "lutlib", 3, 0, {0,1,1,1}, {{0},{1},{1},{1}} };
     If_LibLut_t * pLutLib;
     assert( nLutSize >= 3 && nLutSize <= 10 );
     switch ( nLutSize )
     {
         case 3:  pLutLib = &s_LutLib3; break;
         case 4:  pLutLib = &s_LutLib4; break;
         case 5:  pLutLib = &s_LutLib5; break;
         case 6:  pLutLib = &s_LutLib6; break;
         case 7:  pLutLib = &s_LutLib7; break;
         case 8:  pLutLib = &s_LutLib8; break;
         case 9:  pLutLib = &s_LutLib9; break;
         case 10: pLutLib = &s_LutLib10; break;
         default: pLutLib = NULL; break;
     }
     if ( pLutLib == NULL )
         return NULL;
     return If_LibLutDup(pLutLib);
 }

float If_LibLutSlowestPinDelay ( If_LibLut_t * p )

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

Synopsis [Gets the delay of the slowest pin.]

Description []

SideEffects []

SeeAlso []

Definition at line 335 of file ifLibLut.c.

 {
     return !p? 1.0 : (p->fVarPinDelays? p->pLutDelays[p->LutMax][p->LutMax-1]: p->pLutDelays[p->LutMax][0]);
 }

static int If_ManAndNum ( If_Man_t * p )

inlinestatic

Definition at line 362 of file if.h.

362 { return p->nObjs[IF_AND]; }

IF_AND

Definition: if.h:68

If_Man_t_::nObjs

int nObjs[IF_VOID]

Definition: if.h:192

static If_Obj_t* If_ManCi	(	If_Man_t *	p,
		int	i
	)

inlinestatic

Definition at line 366 of file if.h.

366 { return (If_Obj_t *)Vec_PtrEntry( p->vCis, i ); }

Definition: if.h:303

If_Man_t_::vCis

Vec_Ptr_t * vCis

Definition: if.h:187

static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)

Definition: vecPtr.h:362

static int If_ManCiNum ( If_Man_t * p )

inlinestatic

Definition at line 360 of file if.h.

360 { return p->nObjs[IF_CI]; }

IF_CI

Definition: if.h:66

If_Man_t_::nObjs

int nObjs[IF_VOID]

Definition: if.h:192

void If_ManCleanCutData ( If_Man_t * p )

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

Synopsis [Sets all the cut data to NULL.]

Description []

SideEffects []

SeeAlso []

Definition at line 64 of file ifUtil.c.

 {
     If_Obj_t * pObj;
     int i;
     If_ManForEachObj( p, pObj, i )
         If_CutSetData( If_ObjCutBest(pObj), NULL );
 }

void If_ManCleanMarkV ( If_Man_t * p )

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

Synopsis [Sets all visited marks to 0.]

Description []

SideEffects []

SeeAlso []

Definition at line 83 of file ifUtil.c.

 {
     If_Obj_t * pObj;
     int i;
     If_ManForEachObj( p, pObj, i )
         pObj->fVisit = 0;
 }

void If_ManCleanNodeCopy ( If_Man_t * p )

DECLARATIONS ///.

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

FileName [ifUtil.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [FPGA mapping based on priority cuts.]

Synopsis [Various utilities.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - November 21, 2006.]

Revision [

Id:: ifUtil.c,v 1.00 2006/11/21 00:00:00 alanmi Exp

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

Synopsis [Sets all the node copy to NULL.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file ifUtil.c.

 {
     If_Obj_t * pObj;
     int i;
     If_ManForEachObj( p, pObj, i )
         If_ObjSetCopy( pObj, NULL );
 }

static If_Obj_t* If_ManCo	(	If_Man_t *	p,
		int	i
	)

inlinestatic

Definition at line 367 of file if.h.

367 { return (If_Obj_t *)Vec_PtrEntry( p->vCos, i ); }

Definition: if.h:303

static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)

Definition: vecPtr.h:362

If_Man_t_::vCos

Vec_Ptr_t * vCos

Definition: if.h:188

Vec_Ptr_t* If_ManCollectMappingDirect ( If_Man_t * p )

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

Synopsis [Collects nodes used in the mapping in the topological order.]

Description []

SideEffects []

SeeAlso []

Definition at line 462 of file ifUtil.c.

 {
     Vec_Ptr_t * vOrder;
     If_Obj_t * pObj;
     int i;
     If_ManMarkMapping( p );
     vOrder = Vec_PtrAlloc( If_ManObjNum(p) );
     If_ManForEachObj( p, pObj, i )
         if ( If_ObjIsAnd(pObj) && pObj->nRefs )
             Vec_PtrPush( vOrder, pObj );
     return vOrder;
 }

Vec_Int_t* If_ManCollectMappingInt ( If_Man_t * p )

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

Synopsis [Collects nodes used in the mapping in the topological order.]

Description [Represents mapping as an array of integers.]

SideEffects []

SeeAlso []

Definition at line 486 of file ifUtil.c.

 {
     Vec_Int_t * vOrder;
     If_Cut_t * pCutBest;
     If_Obj_t * pObj;
     int i, k, nLeaves, * ppLeaves;
     If_ManMarkMapping( p );
     vOrder = Vec_IntAlloc( If_ManObjNum(p) );
     If_ManForEachObj( p, pObj, i )
         if ( If_ObjIsAnd(pObj) && pObj->nRefs )
         {
             pCutBest = If_ObjCutBest( pObj );
             nLeaves  = If_CutLeaveNum( pCutBest ); 
             ppLeaves = If_CutLeaves( pCutBest );
             // save the number of leaves, the leaves, and finally, the root
             Vec_IntPush( vOrder, nLeaves );
             for ( k = 0; k < nLeaves; k++ )
                 Vec_IntPush( vOrder, ppLeaves[k] );
             Vec_IntPush( vOrder, pObj->Id );
         }
     return vOrder;
 }

void If_ManComputeRequired ( If_Man_t * p )

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

Synopsis [Computes the required times of all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 294 of file ifTime.c.

 {
     If_Obj_t * pObj;
     int i, Counter;
     float reqTime;
 
     // compute area, clean required times, collect nodes used in the mapping
 //    p->AreaGlo = If_ManScanMapping( p );
     If_ManMarkMapping( p );
     if ( p->pManTim == NULL )
     {
         // consider the case when the required times are given
         if ( p->pPars->pTimesReq && !p->pPars->fAreaOnly )
         {
             // make sure that the required time hold
             Counter = 0;
             If_ManForEachCo( p, pObj, i )
             {
                 if ( If_ObjArrTime(If_ObjFanin0(pObj)) > p->pPars->pTimesReq[i] + p->fEpsilon )
                 {
                     If_ObjFanin0(pObj)->Required = If_ObjArrTime(If_ObjFanin0(pObj));
                     Counter++;
     //                Abc_Print( 0, "Required times are violated for output %d (arr = %d; req = %d).\n", 
     //                    i, (int)If_ObjArrTime(If_ObjFanin0(pObj)), (int)p->pPars->pTimesReq[i] );
                 }
                 else
                     If_ObjFanin0(pObj)->Required = p->pPars->pTimesReq[i];
             }
             if ( Counter && !p->fReqTimeWarn )
             {
                 Abc_Print( 0, "Required times are exceeded at %d output%s. The earliest arrival times are used.\n", Counter, Counter > 1 ? "s":"" );
                 p->fReqTimeWarn = 1;
             }
         }
         else
         {
             // get the global required times
             p->RequiredGlo = If_ManDelayMax( p, 0 );
 
             // find new delay target
             if ( p->pPars->nRelaxRatio && p->pPars->DelayTargetNew == 0 )
                 p->pPars->DelayTargetNew = p->RequiredGlo * (100.0 + p->pPars->nRelaxRatio) / 100.0; 
 
             // update the required times according to the target
             if ( p->pPars->DelayTarget != -1 )
             {
                 if ( p->RequiredGlo > p->pPars->DelayTarget + p->fEpsilon )
                 {
                     if ( p->fNextRound == 0 )
                     {
                         p->fNextRound = 1;
                         Abc_Print( 0, "Cannot meet the target required times (%4.2f). Mapping continues anyway.\n", p->pPars->DelayTarget );
                     }
                 }
                 else if ( p->RequiredGlo < p->pPars->DelayTarget - p->fEpsilon )
                 {
                     if ( p->fNextRound == 0 )
                     {
                         p->fNextRound = 1;
 //                        Abc_Print( 0, "Relaxing the required times from (%4.2f) to the target (%4.2f).\n", p->RequiredGlo, p->pPars->DelayTarget );
                     }
                     p->RequiredGlo = p->pPars->DelayTarget;
                 }
             }
             else if ( p->pPars->DelayTargetNew > 0 ) // relax the required times 
                 p->RequiredGlo = p->pPars->DelayTargetNew;
             // do not propagate required times if area minimization is requested
             if ( p->pPars->fAreaOnly ) 
                 return;
             // set the required times for the POs
             if ( p->pPars->fDoAverage )
             {
                 if ( p->pPars->nRelaxRatio )
                 {
                     If_ManForEachCo( p, pObj, i )
                         If_ObjFanin0(pObj)->Required = If_ObjArrTime(If_ObjFanin0(pObj)) * (100.0 + p->pPars->nRelaxRatio) / 100.0;
                 }
                 else
                 {
                     If_ManForEachCo( p, pObj, i )
                         If_ObjFanin0(pObj)->Required = If_ObjArrTime(If_ObjFanin0(pObj));
                 }
             }
             else if ( p->pPars->fLatchPaths )
             {
                 If_ManForEachLatchInput( p, pObj, i )
                     If_ObjFanin0(pObj)->Required = p->RequiredGlo;
             }
             else 
             {
                 If_ManForEachCo( p, pObj, i )
                     If_ObjFanin0(pObj)->Required = p->RequiredGlo;
             }
         }
         // go through the nodes in the reverse topological order
     //    Vec_PtrForEachEntry( If_Obj_t *, p->vMapped, pObj, i )
     //        If_CutPropagateRequired( p, pObj, If_ObjCutBest(pObj), pObj->Required );
         If_ManForEachObjReverse( p, pObj, i )
         {
             if ( pObj->nRefs == 0 )
                 continue;
             If_CutPropagateRequired( p, pObj, If_ObjCutBest(pObj), pObj->Required );
         }
     }
     else
     {
         // get the global required times
         p->RequiredGlo = If_ManDelayMax( p, 0 );
 
         // find new delay target
         if ( p->pPars->nRelaxRatio && p->pPars->DelayTargetNew == 0 )
             p->pPars->DelayTargetNew = p->RequiredGlo * (100.0 + p->pPars->nRelaxRatio) / 100.0; 
 
         // update the required times according to the target
         if ( p->pPars->DelayTarget != -1 )
         {
             if ( p->RequiredGlo > p->pPars->DelayTarget + p->fEpsilon )
             {
                 if ( p->fNextRound == 0 )
                 {
                     p->fNextRound = 1;
                     Abc_Print( 0, "Cannot meet the target required times (%4.2f). Mapping continues anyway.\n", p->pPars->DelayTarget );
                 }
             }
             else if ( p->RequiredGlo < p->pPars->DelayTarget - p->fEpsilon )
             {
                 if ( p->fNextRound == 0 )
                 {
                     p->fNextRound = 1;
 //                    Abc_Print( 0, "Relaxing the required times from (%4.2f) to the target (%4.2f).\n", p->RequiredGlo, p->pPars->DelayTarget );
                 }
                 p->RequiredGlo = p->pPars->DelayTarget;
             }
         }
         else if ( p->pPars->DelayTargetNew > 0 ) // relax the required times 
             p->RequiredGlo = p->pPars->DelayTargetNew;
 
         // do not propagate required times if area minimization is requested
         if ( p->pPars->fAreaOnly ) 
             return;
         // set the required times for the POs
         Tim_ManIncrementTravId( p->pManTim );
         if ( p->vCoAttrs )
         {
             assert( If_ManCoNum(p) == Vec_IntSize(p->vCoAttrs) );
             If_ManForEachCo( p, pObj, i )
             { 
                 if ( Vec_IntEntry(p->vCoAttrs, i) == -1 )       // -1=internal
                     continue;
                 if ( Vec_IntEntry(p->vCoAttrs, i) == 0 )        //  0=optimize
                     Tim_ManSetCoRequired( p->pManTim, i, p->RequiredGlo );
                 else if ( Vec_IntEntry(p->vCoAttrs, i) == 1 )   //  1=keep
                     Tim_ManSetCoRequired( p->pManTim, i, If_ObjArrTime(If_ObjFanin0(pObj)) );
                 else if ( Vec_IntEntry(p->vCoAttrs, i) == 2 )   //  2=relax
                     Tim_ManSetCoRequired( p->pManTim, i, IF_FLOAT_LARGE );
                 else assert( 0 );
             }
         }
         else if ( p->pPars->fDoAverage )
         {
             if ( p->pPars->nRelaxRatio )
             {
                 If_ManForEachCo( p, pObj, i )
                     Tim_ManSetCoRequired( p->pManTim, i, If_ObjArrTime(If_ObjFanin0(pObj)) * (100.0 + p->pPars->nRelaxRatio) / 100.0 );
             }
             else
             {
                 If_ManForEachCo( p, pObj, i )
                     Tim_ManSetCoRequired( p->pManTim, i, If_ObjArrTime(If_ObjFanin0(pObj)) );
             }
         }
         else if ( p->pPars->fLatchPaths )
         {
             If_ManForEachPo( p, pObj, i )
                 Tim_ManSetCoRequired( p->pManTim, i, IF_FLOAT_LARGE );
             If_ManForEachLatchInput( p, pObj, i )
                 Tim_ManSetCoRequired( p->pManTim, i, p->RequiredGlo );
         }
         else  
         {
             Tim_ManInitPoRequiredAll( p->pManTim, p->RequiredGlo );
 //            If_ManForEachCo( p, pObj, i )
 //                Tim_ManSetCoRequired( p->pManTim, pObj->IdPio, p->RequiredGlo );
         }
         // go through the nodes in the reverse topological order
         If_ManForEachObjReverse( p, pObj, i )
         {
             if ( If_ObjIsAnd(pObj) )
             {
                 if ( pObj->nRefs == 0 )
                     continue;
                 If_CutPropagateRequired( p, pObj, If_ObjCutBest(pObj), pObj->Required );
             }
             else if ( If_ObjIsCi(pObj) )
             {
                 reqTime = pObj->Required;
                 Tim_ManSetCiRequired( p->pManTim, pObj->IdPio, reqTime );
             }
             else if ( If_ObjIsCo(pObj) )
             {
                 reqTime = Tim_ManGetCoRequired( p->pManTim, pObj->IdPio );
                 If_ObjFanin0(pObj)->Required = IF_MIN( reqTime, If_ObjFanin0(pObj)->Required );
             }
             else if ( If_ObjIsConst1(pObj) )
             {
             }
             else // add the node to the mapper
                 assert( 0 );
         }
     }
 }

void If_ManComputeSwitching ( If_Man_t * pIfMan )

FUNCTION DEFINITIONS ///.

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

Synopsis [Interface with the FPGA mapping package.]

Description []

SideEffects []

SeeAlso []

Definition at line 58 of file abcIf.c.

 {
     abctime clk = Abc_Clock();
     Gia_Man_t * pNew;
     Vec_Int_t * vCopy;
     If_Obj_t * pIfObj;
     int i;
     assert( pIfMan->vSwitching == NULL );
     // create the new manager
     pNew = Gia_ManStart( If_ManObjNum(pIfMan) );
     vCopy = Vec_IntAlloc( If_ManObjNum(pIfMan) );
     // constant and inputs
     Vec_IntPush( vCopy, 1 );
     If_ManForEachCi( pIfMan, pIfObj, i )
         Vec_IntPush( vCopy, Gia_ManAppendCi(pNew) );
     // internal nodes
     If_ManForEachNode( pIfMan, pIfObj, i )
     {
         int iLit0 = Abc_LitNotCond( Vec_IntEntry(vCopy, If_ObjFanin0(pIfObj)->Id), If_ObjFaninC0(pIfObj) );
         int iLit1 = Abc_LitNotCond( Vec_IntEntry(vCopy, If_ObjFanin1(pIfObj)->Id), If_ObjFaninC1(pIfObj) );
         Vec_IntPush( vCopy, Gia_ManAppendAnd(pNew, iLit0, iLit1) );
     }
     // outputs
     If_ManForEachCo( pIfMan, pIfObj, i )
     {
         int iLit0 = Abc_LitNotCond( Vec_IntEntry(vCopy, If_ObjFanin0(pIfObj)->Id), If_ObjFaninC0(pIfObj) );
         Vec_IntPush( vCopy, Gia_ManAppendCo(pNew, iLit0) );
     }
     assert( Vec_IntSize(vCopy) == If_ManObjNum(pIfMan) );
     Vec_IntFree( vCopy );
     // compute switching activity
     pIfMan->vSwitching = Gia_ManComputeSwitchProbs( pNew, 48, 16, 0 );
     Gia_ManStop( pNew );
     if ( pIfMan->pPars->fVerbose )
         Abc_PrintTime( 1, "Computing switching activity", Abc_Clock() - clk );
 }

static If_Obj_t* If_ManConst1 ( If_Man_t * p )

inlinestatic

Definition at line 365 of file if.h.

365 { return p->pConst1; }

If_Man_t_::pConst1

If_Obj_t * pConst1

Definition: if.h:186

static int If_ManCoNum ( If_Man_t * p )

inlinestatic

Definition at line 361 of file if.h.

361 { return p->nObjs[IF_CO]; }

IF_CO

Definition: if.h:67

If_Man_t_::nObjs

int nObjs[IF_VOID]

Definition: if.h:192

int If_ManCountSpecialPos ( If_Man_t * p )

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

Synopsis [Returns the number of POs pointing to the same internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 520 of file ifUtil.c.

 {
     If_Obj_t * pObj;
     int i, Counter = 0;
     // clean all marks
     If_ManForEachPo( p, pObj, i )
         If_ObjFanin0(pObj)->fMark = 0;
     // label nodes 
     If_ManForEachPo( p, pObj, i )
         if ( !If_ObjFaninC0(pObj) )
             If_ObjFanin0(pObj)->fMark = 1;
     // label nodes 
     If_ManForEachPo( p, pObj, i )
         if ( If_ObjFaninC0(pObj) )
             Counter += If_ObjFanin0(pObj)->fMark;
     // clean all marks
     If_ManForEachPo( p, pObj, i )
         If_ObjFanin0(pObj)->fMark = 0;
     return Counter;
 }

If_Obj_t* If_ManCreateAnd	(	If_Man_t *	p,
		If_Obj_t *	pFan0,
		If_Obj_t *	pFan1
	)

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

Synopsis [Create the new node assuming it does not exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 366 of file ifMan.c.

 {
     If_Obj_t * pObj;
     // perform constant propagation
     if ( pFan0 == pFan1 )
         return pFan0;
     if ( pFan0 == If_Not(pFan1) )
         return If_Not(p->pConst1);
     if ( If_Regular(pFan0) == p->pConst1 )
         return pFan0 == p->pConst1 ? pFan1 : If_Not(p->pConst1);
     if ( If_Regular(pFan1) == p->pConst1 )
         return pFan1 == p->pConst1 ? pFan0 : If_Not(p->pConst1);
     // get memory for the new object
     pObj = If_ManSetupObj( p );
     pObj->Type    = IF_AND;
     pObj->fCompl0 = If_IsComplement(pFan0); pFan0 = If_Regular(pFan0);
     pObj->fCompl1 = If_IsComplement(pFan1); pFan1 = If_Regular(pFan1);
     pObj->pFanin0 = pFan0; pFan0->nRefs++; pFan0->nVisits++; pFan0->nVisitsCopy++;
     pObj->pFanin1 = pFan1; pFan1->nRefs++; pFan1->nVisits++; pFan1->nVisitsCopy++;
     pObj->fPhase  = (pObj->fCompl0 ^ pFan0->fPhase) & (pObj->fCompl1 ^ pFan1->fPhase);
     pObj->Level   = 1 + IF_MAX( pFan0->Level, pFan1->Level );
     if ( p->nLevelMax < (int)pObj->Level )
         p->nLevelMax = (int)pObj->Level;
     p->nObjs[IF_AND]++;
     return pObj;
 }

void If_ManCreateChoice	(	If_Man_t *	p,
		If_Obj_t *	pObj
	)

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

Synopsis [Creates the choice node.]

Description [Should be called after the equivalence class nodes are linked.]

SideEffects []

SeeAlso []

Definition at line 442 of file ifMan.c.

 {
     If_Obj_t * pTemp;
     // mark the node as a representative if its class
     assert( pObj->fRepr == 0 );
     pObj->fRepr = 1;
     // update the level of this node (needed for correct required time computation)
     for ( pTemp = pObj; pTemp; pTemp = pTemp->pEquiv )
     {
         pObj->Level = IF_MAX( pObj->Level, pTemp->Level );
         pTemp->nVisits++; pTemp->nVisitsCopy++;
     }
     // mark the largest level
     if ( p->nLevelMax < (int)pObj->Level )
         p->nLevelMax = (int)pObj->Level;
     p->nChoices++;
 }

If_Obj_t* If_ManCreateCi ( If_Man_t * p )

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

Synopsis [Creates primary input.]

Description []

SideEffects []

SeeAlso []

Definition at line 316 of file ifMan.c.

 {
     If_Obj_t * pObj;
     pObj = If_ManSetupObj( p );
     pObj->Type = IF_CI;
     pObj->IdPio = Vec_PtrSize( p->vCis );
     Vec_PtrPush( p->vCis, pObj );
     p->nObjs[IF_CI]++;
     return pObj;
 }

If_Obj_t* If_ManCreateCo	(	If_Man_t *	p,
		If_Obj_t *	pDriver
	)

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

Synopsis [Creates primary output with the given driver.]

Description []

SideEffects []

SeeAlso []

Definition at line 338 of file ifMan.c.

 {
     If_Obj_t * pObj;
     pObj = If_ManSetupObj( p );
     pObj->IdPio = Vec_PtrSize( p->vCos );
     Vec_PtrPush( p->vCos, pObj );
     pObj->Type = IF_CO;
     pObj->fCompl0 = If_IsComplement(pDriver); pDriver = If_Regular(pDriver);
     pObj->pFanin0 = pDriver; pDriver->nRefs++; 
     pObj->fPhase  = (pObj->fCompl0 ^ pDriver->fPhase);
     pObj->Level   = pDriver->Level;
     if ( p->nLevelMax < (int)pObj->Level )
         p->nLevelMax = (int)pObj->Level;
     p->nObjs[IF_CO]++;
     return pObj;
 }

If_Obj_t* If_ManCreateMux	(	If_Man_t *	p,
		If_Obj_t *	pFan0,
		If_Obj_t *	pFan1,
		If_Obj_t *	pCtrl
	)

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

Synopsis [Create the new node assuming it does not exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 423 of file ifMan.c.

 {
     If_Obj_t * pRes1, * pRes2;
     pRes1 = If_ManCreateAnd( p, pFan0, If_Not(pCtrl) );
     pRes2 = If_ManCreateAnd( p, pFan1, pCtrl );
     return If_Not( If_ManCreateAnd( p, If_Not(pRes1), If_Not(pRes2) ) );
 }

If_Obj_t* If_ManCreateXor	(	If_Man_t *	p,
		If_Obj_t *	pFan0,
		If_Obj_t *	pFan1
	)

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

Synopsis [Create the new node assuming it does not exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 404 of file ifMan.c.

 {
     If_Obj_t * pRes1, * pRes2;
     pRes1 = If_ManCreateAnd( p, If_Not(pFan0), pFan1 );
     pRes2 = If_ManCreateAnd( p, pFan0, If_Not(pFan1) );
     return If_Not( If_ManCreateAnd( p, If_Not(pRes1), If_Not(pRes2) ) );
 }

int If_ManCrossCut ( If_Man_t * p )

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

Synopsis [Computes cross-cut of the circuit.]

Description []

SideEffects []

SeeAlso []

Definition at line 316 of file ifUtil.c.

 {
     If_Obj_t * pObj, * pFanin;
     int i, nCutSize = 0, nCutSizeMax = 0;
     If_ManForEachObj( p, pObj, i )
     {
         if ( !If_ObjIsAnd(pObj) )
             continue;
         // consider the node
         if ( nCutSizeMax < ++nCutSize )
             nCutSizeMax = nCutSize;
         if ( pObj->nVisits == 0 )
             nCutSize--;
         // consider the fanins
         pFanin = If_ObjFanin0(pObj);
         if ( !If_ObjIsCi(pFanin) && --pFanin->nVisits == 0 )
             nCutSize--;
         pFanin = If_ObjFanin1(pObj);
         if ( !If_ObjIsCi(pFanin) && --pFanin->nVisits == 0 )
             nCutSize--;
         // consider the choice class
         if ( pObj->fRepr )
             for ( pFanin = pObj; pFanin; pFanin = pFanin->pEquiv )
                 if ( !If_ObjIsCi(pFanin) && --pFanin->nVisits == 0 )
                     nCutSize--;
     }
     If_ManForEachObj( p, pObj, i )
     {
         assert( If_ObjIsCi(pObj) || pObj->fVisit == 0 );
         pObj->nVisits = pObj->nVisitsCopy;
     }
     assert( nCutSize == 0 );
 //    Abc_Print( 1, "Max cross cut size = %6d.\n", nCutSizeMax );
     return nCutSizeMax;
 }

float If_ManDelayMax	(	If_Man_t *	p,
		int	fSeq
	)

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

Synopsis [Returns the max delay of the POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 250 of file ifTime.c.

 {
     If_Obj_t * pObj;
     float DelayBest;
     int i;
     if ( p->pPars->fLatchPaths && (p->pPars->nLatchesCi == 0 || p->pPars->nLatchesCo == 0) )
     {
         Abc_Print( 0, "Delay optimization of latch path is not performed because there is no latches.\n" );
         p->pPars->fLatchPaths = 0;
     }
     DelayBest = -IF_FLOAT_LARGE;
     if ( fSeq )
     {
         assert( p->pPars->nLatchesCi > 0 );
         If_ManForEachPo( p, pObj, i )
             if ( DelayBest < If_ObjArrTime(If_ObjFanin0(pObj)) )
                  DelayBest = If_ObjArrTime(If_ObjFanin0(pObj));
     }
     else if ( p->pPars->fLatchPaths )
     {
         If_ManForEachLatchInput( p, pObj, i )
             if ( DelayBest < If_ObjArrTime(If_ObjFanin0(pObj)) )
                  DelayBest = If_ObjArrTime(If_ObjFanin0(pObj));
     }
     else 
     {
         If_ManForEachCo( p, pObj, i )
             if ( DelayBest < If_ObjArrTime(If_ObjFanin0(pObj)) )
                  DelayBest = If_ObjArrTime(If_ObjFanin0(pObj));
     }
     return DelayBest;
 }

void If_ManDerefChoiceCutSet	(	If_Man_t *	p,
		If_Obj_t *	pObj
	)

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

Synopsis [Dereferences cutset of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 645 of file ifMan.c.

 {
     If_Obj_t * pTemp;
     assert( If_ObjIsAnd(pObj) );
     assert( pObj->fRepr );
     assert( pObj->nVisits > 0 );
     // consider the nodes in the choice class
     for ( pTemp = pObj; pTemp; pTemp = pTemp->pEquiv )
     {
 //        assert( pTemp == pObj || pTemp->nVisits == 1 );
         if ( --pTemp->nVisits == 0 )
         {
 //            Mem_FixedEntryRecycle( p->pMemSet, (char *)pTemp->pCutSet );
             If_ManCutSetRecycle( p, pTemp->pCutSet );
             pTemp->pCutSet = NULL;
         }
     }
 }

void If_ManDerefNodeCutSet	(	If_Man_t *	p,
		If_Obj_t *	pObj
	)

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

Synopsis [Dereferences cutset of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 602 of file ifMan.c.

 {
     If_Obj_t * pFanin;
     assert( If_ObjIsAnd(pObj) );
     // consider the node
     assert( pObj->nVisits >= 0 );
     if ( pObj->nVisits == 0 )
     {
 //        Mem_FixedEntryRecycle( p->pMemSet, (char *)pObj->pCutSet );
         If_ManCutSetRecycle( p, pObj->pCutSet );
         pObj->pCutSet = NULL;
     }
     // consider the first fanin
     pFanin = If_ObjFanin0(pObj);
     assert( pFanin->nVisits > 0 );
     if ( !If_ObjIsCi(pFanin) && --pFanin->nVisits == 0 )
     {
 //        Mem_FixedEntryRecycle( p->pMemSet, (char *)pFanin->pCutSet );
         If_ManCutSetRecycle( p, pFanin->pCutSet );
         pFanin->pCutSet = NULL;
     }
     // consider the second fanin
     pFanin = If_ObjFanin1(pObj);
     assert( pFanin->nVisits > 0 );
     if ( !If_ObjIsCi(pFanin) && --pFanin->nVisits == 0 )
     {
 //        Mem_FixedEntryRecycle( p->pMemSet, (char *)pFanin->pCutSet );
         If_ManCutSetRecycle( p, pFanin->pCutSet );
         pFanin->pCutSet = NULL;
     }
 }

void If_ManImproveMapping ( If_Man_t * p )

FUNCTION DEFINITIONS ///.

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

Synopsis [Improves current mapping using expand/Expand of one cut.]

Description [Assumes current mapping assigned and required times computed.]

SideEffects []

SeeAlso []

Definition at line 51 of file ifReduce.c.

 {
     abctime clk;
 
     clk = Abc_Clock();
     If_ManImproveExpand( p, p->pPars->nLutSize );
     If_ManComputeRequired( p );
     if ( p->pPars->fVerbose )
     {
         Abc_Print( 1, "E:  Del = %7.2f.  Ar = %9.1f.  Edge = %8d.  ", 
             p->RequiredGlo, p->AreaGlo, p->nNets );
         if ( p->dPower )
         Abc_Print( 1, "Switch = %7.2f.  ", p->dPower );
         Abc_Print( 1, "Cut = %8d.  ", p->nCutsMerged );
         Abc_PrintTime( 1, "T", Abc_Clock() - clk );
     }
 }

static If_Obj_t* If_ManLi	(	If_Man_t *	p,
		int	i
	)

inlinestatic

Definition at line 368 of file if.h.

368 { return (If_Obj_t *)Vec_PtrEntry( p->vCos, If_ManCoNum(p) - p->pPars->nLatchesCo + i ); }

Definition: if.h:303

static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)

Definition: vecPtr.h:362

If_Par_t * pPars

Definition: if.h:184

If_Par_t_::nLatchesCo

int nLatchesCo

Definition: if.h:153

If_Man_t_::vCos

Vec_Ptr_t * vCos

Definition: if.h:188

If_ManCoNum

static int If_ManCoNum(If_Man_t *p)

Definition: if.h:361

static If_Obj_t* If_ManLo	(	If_Man_t *	p,
		int	i
	)

inlinestatic

Definition at line 369 of file if.h.

369 { return (If_Obj_t *)Vec_PtrEntry( p->vCis, If_ManCiNum(p) - p->pPars->nLatchesCi + i ); }

Definition: if.h:303

If_Par_t_::nLatchesCi

int nLatchesCi

Definition: if.h:152

If_ManCiNum

static int If_ManCiNum(If_Man_t *p)

Definition: if.h:360

If_Man_t_::vCis

Vec_Ptr_t * vCis

Definition: if.h:187

static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)

Definition: vecPtr.h:362

If_Par_t * pPars

Definition: if.h:184

void If_ManMarkMapping ( If_Man_t * p )

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

Synopsis [Computes area, references, and nodes used in the mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 434 of file ifUtil.c.

 {
     If_Obj_t * pObj;
     int i;
     If_ManForEachObj( p, pObj, i )
     {
         pObj->Required = IF_FLOAT_LARGE;
         pObj->nVisits = pObj->nVisitsCopy;
         pObj->nRefs = 0;
     }
     p->nNets = 0;
     p->dPower = 0.0;
     p->AreaGlo = 0.0;
     If_ManForEachCo( p, pObj, i )
         p->AreaGlo += If_ManMarkMapping_rec( p, If_ObjFanin0(pObj) );
 }

static If_Obj_t* If_ManObj	(	If_Man_t *	p,
		int	i
	)

inlinestatic

Definition at line 370 of file if.h.

370 { return (If_Obj_t *)Vec_PtrEntry( p->vObjs, i ); }

If_Man_t_::vObjs

Vec_Ptr_t * vObjs

Definition: if.h:189

Definition: if.h:303

static void * Vec_PtrEntry(Vec_Ptr_t *p, int i)

Definition: vecPtr.h:362

static int If_ManObjNum ( If_Man_t * p )

inlinestatic

Definition at line 363 of file if.h.

363 { return Vec_PtrSize(p->vObjs); }

If_Man_t_::vObjs

Vec_Ptr_t * vObjs

Definition: if.h:189

Vec_PtrSize

static int Vec_PtrSize(Vec_Ptr_t *p)

Definition: vecPtr.h:295

int If_ManPerformMapping ( If_Man_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 80 of file ifCore.c.

 {
     p->pPars->fAreaOnly = p->pPars->fArea; // temporary
     // create the CI cutsets
     If_ManSetupCiCutSets( p );
     // allocate memory for other cutsets
     If_ManSetupSetAll( p, If_ManCrossCut(p) );
     // derive reverse top order
     p->vObjsRev = If_ManReverseOrder( p );
     return If_ManPerformMappingComb( p );
 }

int If_ManPerformMappingComb ( If_Man_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 104 of file ifCore.c.

 {
     If_Obj_t * pObj;
     abctime clkTotal = Abc_Clock();
     int i;
 
     // set arrival times and fanout estimates
     If_ManForEachCi( p, pObj, i )
     {
         If_ObjSetArrTime( pObj, p->pPars->pTimesArr ? p->pPars->pTimesArr[i] : (float)0.0 );
         pObj->EstRefs = (float)1.0;
     }
 
     // delay oriented mapping
     if ( p->pPars->fPreprocess && !p->pPars->fArea )
     {
         // map for delay
         If_ManPerformMappingRound( p, p->pPars->nCutsMax, 0, 1, 1, "Delay" );
         // map for delay second option
         p->pPars->fFancy = 1;
         If_ManResetOriginalRefs( p );
         If_ManPerformMappingRound( p, p->pPars->nCutsMax, 0, 1, 0, "Delay-2" );
         p->pPars->fFancy = 0;
         // map for area
         p->pPars->fArea = 1;
         If_ManResetOriginalRefs( p );
         If_ManPerformMappingRound( p, p->pPars->nCutsMax, 0, 1, 0, "Area" );
         p->pPars->fArea = 0;
     }
     else
         If_ManPerformMappingRound( p, p->pPars->nCutsMax, 0, 0, 1, "Delay" );
 
     // try to improve area by expanding and reducing the cuts
     if ( p->pPars->fExpRed )
         If_ManImproveMapping( p );
 
     // area flow oriented mapping
     for ( i = 0; i < p->pPars->nFlowIters; i++ )
     {
         If_ManPerformMappingRound( p, p->pPars->nCutsMax, 1, 0, 0, "Flow" );
         if ( p->pPars->fExpRed )
             If_ManImproveMapping( p );
     }
 
     // area oriented mapping
     for ( i = 0; i < p->pPars->nAreaIters; i++ )
     {
         If_ManPerformMappingRound( p, p->pPars->nCutsMax, 2, 0, 0, "Area" );
         if ( p->pPars->fExpRed )
             If_ManImproveMapping( p );
     }
 
     if ( p->pPars->fVerbose )
     {
 //        Abc_Print( 1, "Total memory = %7.2f MB. Peak cut memory = %7.2f MB.  ", 
 //            1.0 * (p->nObjBytes + 2*sizeof(void *)) * If_ManObjNum(p) / (1<<20), 
 //            1.0 * p->nSetBytes * Mem_FixedReadMaxEntriesUsed(p->pMemSet) / (1<<20) );
         Abc_PrintTime( 1, "Total time", Abc_Clock() - clkTotal );
     }
 //    Abc_Print( 1, "Cross cut memory = %d.\n", Mem_FixedReadMaxEntriesUsed(p->pMemSet) );
     s_MappingTime = Abc_Clock() - clkTotal;
 //    Abc_Print( 1, "Special POs = %d.\n", If_ManCountSpecialPos(p) );
 
 /*
     {
         static char * pLastName = NULL;
         FILE * pTable = fopen( "fpga/ucsb/stats.txt", "a+" );
         if ( pLastName == NULL || strcmp(pLastName, p->pName) )
         {
             fprintf( pTable, "\n" );
             fprintf( pTable, "%s ", p->pName );
 
             fprintf( pTable, "%d ", If_ManCiNum(p) );
             fprintf( pTable, "%d ", If_ManCoNum(p) );
             fprintf( pTable, "%d ", If_ManAndNum(p) );
 
             ABC_FREE( pLastName );
             pLastName = Abc_UtilStrsav( p->pName );
         }
 
         fprintf( pTable, "%d ", (int)p->AreaGlo );
         fprintf( pTable, "%d ", (int)p->RequiredGlo );
         fclose( pTable );
     }
 */
     p->pPars->FinalDelay = p->RequiredGlo;
     return 1;
 }

int If_ManPerformMappingRound	(	If_Man_t *	p,
		int	nCutsUsed,
		int	Mode,
		int	fPreprocess,
		int	fFirst,
		char *	pLabel
	)

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

Synopsis [Performs one mapping pass over all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 491 of file ifMap.c.

 {
 //    ProgressBar * pProgress;
     If_Obj_t * pObj;
     int i;
     abctime clk = Abc_Clock();
     float arrTime;
     assert( Mode >= 0 && Mode <= 2 );
     p->nBestCutSmall[0] = p->nBestCutSmall[1] = 0;
     // set the sorting function
     if ( Mode || p->pPars->fArea ) // area
         p->SortMode = 1;
     else if ( p->pPars->fFancy )
         p->SortMode = 2;
     else
         p->SortMode = 0;
     // set the cut number
     p->nCutsUsed   = nCutsUsed;
     p->nCutsMerged = 0;
     // make sure the visit counters are all zero
     If_ManForEachNode( p, pObj, i )
         assert( pObj->nVisits == pObj->nVisitsCopy );
     // map the internal nodes
     if ( p->pManTim != NULL )
     {
         Tim_ManIncrementTravId( p->pManTim );
         If_ManForEachObj( p, pObj, i )
         {
             if ( If_ObjIsAnd(pObj) )
             {
                 If_ObjPerformMappingAnd( p, pObj, Mode, fPreprocess, fFirst );
                 if ( pObj->fRepr )
                     If_ObjPerformMappingChoice( p, pObj, Mode, fPreprocess );
             }
             else if ( If_ObjIsCi(pObj) )
             {
 //Abc_Print( 1, "processing CI %d\n", pObj->Id );
                 arrTime = Tim_ManGetCiArrival( p->pManTim, pObj->IdPio );
                 If_ObjSetArrTime( pObj, arrTime );
             }
             else if ( If_ObjIsCo(pObj) )
             {
                 arrTime = If_ObjArrTime( If_ObjFanin0(pObj) );
                 Tim_ManSetCoArrival( p->pManTim, pObj->IdPio, arrTime );
             }
             else if ( If_ObjIsConst1(pObj) )
             {
             }
             else
                 assert( 0 );
         }
 //        Tim_ManPrint( p->pManTim );
     }
     else
     {
     //    pProgress = Extra_ProgressBarStart( stdout, If_ManObjNum(p) );
         If_ManForEachNode( p, pObj, i )
         {
     //        Extra_ProgressBarUpdate( pProgress, i, pLabel );
             If_ObjPerformMappingAnd( p, pObj, Mode, fPreprocess, fFirst );
             if ( pObj->fRepr )
                 If_ObjPerformMappingChoice( p, pObj, Mode, fPreprocess );
         }
     }
 //    Extra_ProgressBarStop( pProgress );
     // make sure the visit counters are all zero
     If_ManForEachNode( p, pObj, i )
         assert( pObj->nVisits == 0 );
     // compute required times and stats
     If_ManComputeRequired( p );
 //    Tim_ManPrint( p->pManTim );
     if ( p->pPars->fVerbose )
     {
         char Symb = fPreprocess? 'P' : ((Mode == 0)? 'D' : ((Mode == 1)? 'F' : 'A'));
         Abc_Print( 1, "%c:  Del = %7.2f.  Ar = %9.1f.  Edge = %8d.  ", 
             Symb, p->RequiredGlo, p->AreaGlo, p->nNets );
         if ( p->dPower )
         Abc_Print( 1, "Switch = %7.2f.  ", p->dPower );
         Abc_Print( 1, "Cut = %8d.  ", p->nCutsMerged );
         Abc_PrintTime( 1, "T", Abc_Clock() - clk );
 //    Abc_Print( 1, "Max number of cuts = %d. Average number of cuts = %5.2f.\n", 
 //        p->nCutsMax, 1.0 * p->nCutsMerged / If_ManAndNum(p) );
     }
     return 1;
 }

int If_ManPerformMappingSeq ( If_Man_t * p )

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

Synopsis [Performs sequential mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 334 of file ifSeq.c.

 {
     abctime clkTotal = Abc_Clock();
     int PeriodBest;
 
     p->SortMode = 0;
 
     // perform combinational mapping to get the upper bound on the clock period
     If_ManPerformMappingRound( p, 1, 0, 0, 1, NULL );
     p->RequiredGlo  = If_ManDelayMax( p, 0 );
     p->RequiredGlo2 = p->RequiredGlo;
 
     // set direct linking of latches with their inputs
     If_ManPrepareMappingSeq( p );
 
     // collect latches
     p->vLatchOrder = If_ManCollectLatches( p );
 
     // set parameters
     p->nCutsUsed = p->pPars->nCutsMax;
     p->nAttempts = 0;
     p->nMaxIters = 50;
     p->Period    = (int)p->RequiredGlo;
 
     // make sure the clock period works
     if ( !If_ManBinarySearchPeriod( p ) )
     {
         Abc_Print( 1, "If_ManPerformMappingSeq(): The upper bound on the clock period cannot be computed.\n" );
         return 0;
     }
 
     // perform binary search
     PeriodBest = If_ManBinarySearch_rec( p, 0, p->Period );
 
     // recompute the best l-values
     if ( p->Period != PeriodBest )
     {
         p->Period = PeriodBest;
         if ( !If_ManBinarySearchPeriod( p ) )
         {
             Abc_Print( 1, "If_ManPerformMappingSeq(): The final clock period cannot be confirmed.\n" );
             return 0;
         }
     }
 //    if ( p->pPars->fVerbose )
     {
         Abc_Print( 1, "The best clock period is %3d.  ", p->Period );
         Abc_PrintTime( 1, "Time", Abc_Clock() - clkTotal );
     }
     p->RequiredGlo = (float)(PeriodBest);
 
     // postprocess it using combinational mapping
     If_ManPerformMappingSeqPost( p );
     s_MappingTime = Abc_Clock() - clkTotal;
     return 1;
 }

void If_ManResetOriginalRefs ( If_Man_t * p )

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

Synopsis [Computes area, references, and nodes used in the mapping.]

Description [Collects the nodes in reverse topological order in array p->vMapping.]

SideEffects []

SeeAlso []

Definition at line 287 of file ifUtil.c.

 {
     If_Obj_t * pObj;
     int i;
     If_ManForEachObj( p, pObj, i )
         pObj->nRefs = 0;
     If_ManForEachObj( p, pObj, i )
     {
         if ( If_ObjIsAnd(pObj) )
         {
             pObj->pFanin0->nRefs++;
             pObj->pFanin1->nRefs++;
         }
         else if ( If_ObjIsCo(pObj) )
             pObj->pFanin0->nRefs++;
     }
 }

void If_ManRestart ( If_Man_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 178 of file ifMan.c.

 {
     ABC_FREE( p->pMemCi );
     Vec_PtrClear( p->vCis );
     Vec_PtrClear( p->vCos );
     Vec_PtrClear( p->vObjs );
     Vec_PtrClear( p->vTemp );
     Mem_FixedRestart( p->pMemObj );
     // create the constant node
     p->pConst1 = If_ManSetupObj( p );
     p->pConst1->Type = IF_CONST1;
     p->pConst1->fPhase = 1;
     // reset the counter of other nodes
     p->nObjs[IF_CI] = p->nObjs[IF_CO] = p->nObjs[IF_AND] = 0;
 }

Vec_Ptr_t* If_ManReverseOrder ( If_Man_t * p )

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

Synopsis [Computes the reverse topological order of nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 363 of file ifUtil.c.

 {
     Vec_Ptr_t * vOrder;
     If_Obj_t * pObj, ** ppStore;
     int i;
     // allocate place to store the nodes
     ppStore = ABC_ALLOC( If_Obj_t *, p->nLevelMax + 1 );
     memset( ppStore, 0, sizeof(If_Obj_t *) * (p->nLevelMax + 1) );
     // add the nodes
     If_ManForEachObj( p, pObj, i )
     {
         assert( pObj->Level >= 0 && pObj->Level <= (unsigned)p->nLevelMax );
         pObj->pCopy = (char *)ppStore[pObj->Level]; 
         ppStore[pObj->Level] = pObj;
     }
     vOrder = Vec_PtrAlloc( If_ManObjNum(p) );
     for ( i = p->nLevelMax; i >= 0; i-- )
         for ( pObj = ppStore[i]; pObj; pObj = (If_Obj_t *)pObj->pCopy )
             Vec_PtrPush( vOrder, pObj );
     ABC_FREE( ppStore );
     // print the order
 //    Vec_PtrForEachEntry( If_Obj_t *, vOrder, pObj, i )
 //        Abc_Print( 1, "Obj %2d   Type %d  Level = %d\n", pObj->Id, pObj->Type, pObj->Level );
     return vOrder;
 }

void* If_ManSatBuildFromCell	(	char *	pStr,
		Vec_Int_t **	pvPiVars,
		Vec_Int_t **	pvPoVars,
		Ifn_Ntk_t **	ppNtk
	)

Definition at line 622 of file ifTune.c.

 {
     Ifn_Ntk_t * p = Ifn_NtkParse( pStr );
     Ifn_Prepare( p, NULL, p->nInps );
     *ppNtk = p;
     if ( p == NULL )
         return NULL;
 //    Ifn_NtkPrint( p );
     return Ifn_ManSatBuild( p, pvPiVars, pvPoVars );
 }

void* If_ManSatBuildXY ( int nLutSize )

DECLARATIONS ///.

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

FileName [ifSat.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [FPGA mapping based on priority cuts.]

Synopsis [SAT-based evaluation.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - November 21, 2006.]

Revision [

Id:: ifSat.c,v 1.00 2006/11/21 00:00:00 alanmi Exp

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

Synopsis [Builds SAT instance for the given structure.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file ifSat.c.

 {
     int nMintsL = (1 << nLutSize);
     int nMintsF = (1 << (2 * nLutSize - 1));
     int nVars   = 2 * nMintsL + nMintsF;
     int iVarP0  = 0;           // LUT0 parameters (total nMintsL)
     int iVarP1  = nMintsL;     // LUT1 parameters (total nMintsL)
     int m,iVarM = 2 * nMintsL; // MUX vars        (total nMintsF)
     sat_solver * p = sat_solver_new();
     sat_solver_setnvars( p, nVars );
     for ( m = 0; m < nMintsF; m++ )
         sat_solver_add_mux( p, 
             iVarP0 + m % nMintsL, 
             iVarP1 + 2 * (m / nMintsL) + 1, 
             iVarP1 + 2 * (m / nMintsL), 
             iVarM + m );
     return p;
 }

void* If_ManSatBuildXYZ ( int nLutSize )

Definition at line 63 of file ifSat.c.

 {
     int nMintsL = (1 << nLutSize);
     int nMintsF = (1 << (3 * nLutSize - 2));
     int nVars   = 3 * nMintsL + nMintsF;
     int iVarP0  = 0;           // LUT0 parameters (total nMintsL)
     int iVarP1  = nMintsL;     // LUT1 parameters (total nMintsL)
     int iVarP2  = 2 * nMintsL; // LUT2 parameters (total nMintsL)
     int m,iVarM = 3 * nMintsL; // MUX vars        (total nMintsF)
     sat_solver * p = sat_solver_new();
     sat_solver_setnvars( p, nVars );
     for ( m = 0; m < nMintsF; m++ )
         sat_solver_add_mux41( p, 
             iVarP0 + m % nMintsL, 
             iVarP1 + (m >> nLutSize) % nMintsL, 
             iVarP2 + 4 * (m >> (2 * nLutSize)) + 0, 
             iVarP2 + 4 * (m >> (2 * nLutSize)) + 1, 
             iVarP2 + 4 * (m >> (2 * nLutSize)) + 2, 
             iVarP2 + 4 * (m >> (2 * nLutSize)) + 3, 
             iVarM + m );
     return p;
 }

int If_ManSatCheckXY	(	void *	pSat,
		int	nLutSize,
		word *	pTruth,
		int	nVars,
		unsigned	uSet,
		word *	pTBound,
		word *	pTFree,
		Vec_Int_t *	vLits
	)

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

Synopsis [Returns config string for the given truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 150 of file ifSat.c.

 {
     sat_solver * p = (sat_solver *)pSat;
     int iBSet, nBSet = 0, pBSet[IF_MAX_FUNC_LUTSIZE];
     int iSSet, nSSet = 0, pSSet[IF_MAX_FUNC_LUTSIZE];
     int iFSet, nFSet = 0, pFSet[IF_MAX_FUNC_LUTSIZE];
     int nMintsL = (1 << nLutSize);
     int nMintsF = (1 << (2 * nLutSize - 1));
     int v, Value, m, mNew, nMintsFNew, nMintsLNew;
     word Res;
     // collect variable sets
     Dau_DecSortSet( uSet, nVars, &nBSet, &nSSet, &nFSet );
     assert( nBSet + nSSet + nFSet == nVars );
     // check variable bounds
     assert( nSSet + nBSet <= nLutSize );
     assert( nLutSize + nSSet + nFSet <= 2*nLutSize - 1 );
     nMintsFNew = (1 << (nLutSize + nSSet + nFSet));
     // remap minterms
     Vec_IntFill( vLits, nMintsF, -1 );
     for ( m = 0; m < (1 << nVars); m++ )
     {
         mNew = iBSet = iSSet = iFSet = 0;
         for ( v = 0; v < nVars; v++ )
         {
             Value = ((uSet >> (v << 1)) & 3);
             if ( Value == 0 ) // FS
             {
                 if ( ((m >> v) & 1) )
                     mNew |= 1 << (nLutSize + nSSet + iFSet), pFSet[iFSet] = v;
                 iFSet++;
             }
             else if ( Value == 1 ) // BS
             {
                 if ( ((m >> v) & 1) )
                     mNew |= 1 << (nSSet + iBSet), pBSet[iBSet] = v;
                 iBSet++;
             }
             else if ( Value == 3 ) // SS
             {
                 if ( ((m >> v) & 1) )
                 {
                     mNew |= 1 << iSSet;
                     mNew |= 1 << (nLutSize + iSSet);
                     pSSet[iSSet] = v;
                 }
                 iSSet++;
             }
             else assert( Value == 0 );
         }
         assert( iBSet == nBSet && iFSet == nFSet );
         assert( Vec_IntEntry(vLits, mNew) == -1 );
         Vec_IntWriteEntry( vLits, mNew, Abc_TtGetBit(pTruth, m) );
     }
     // find assumptions
     v = 0;
     Vec_IntForEachEntry( vLits, Value, m )
     {
 //        printf( "%d", (Value >= 0) ? Value : 2 );
         if ( Value >= 0 )
             Vec_IntWriteEntry( vLits, v++, Abc_Var2Lit(2 * nMintsL + m, !Value) );
     }
     Vec_IntShrink( vLits, v );
 //    printf( " %d\n", Vec_IntSize(vLits) );
     // run SAT solver
     Value = sat_solver_solve( p, Vec_IntArray(vLits), Vec_IntArray(vLits) + Vec_IntSize(vLits), 0, 0, 0, 0 );
     if ( Value != l_True )
         return 0;
     if ( pTBound && pTFree )
     {
         // collect config
         assert( nSSet + nBSet <= nLutSize );
         *pTBound = 0;
         nMintsLNew = (1 << (nSSet + nBSet));
         for ( m = 0; m < nMintsLNew; m++ )
             if ( sat_solver_var_value(p, m) )
                 Abc_TtSetBit( pTBound, m );
         *pTBound = Abc_Tt6Stretch( *pTBound, nSSet + nBSet );
         // collect configs
         assert( nSSet + nFSet + 1 <= nLutSize );
         *pTFree = 0;
         nMintsLNew = (1 << (1 + nSSet + nFSet));
         for ( m = 0; m < nMintsLNew; m++ )
             if ( sat_solver_var_value(p, nMintsL+m) )
                 Abc_TtSetBit( pTFree, m );
         *pTFree = Abc_Tt6Stretch( *pTFree, 1 + nSSet + nFSet );
         if ( nVars != 6 || nLutSize != 4 )
             return 1;
         // verify the result
         Res = If_ManSat6Truth( *pTBound, *pTFree, pBSet, nBSet, pSSet, nSSet, pFSet, nFSet );
         if ( pTruth[0] != Res )
         {
             Dau_DsdPrintFromTruth( pTruth,  nVars );
             Dau_DsdPrintFromTruth( &Res,    nVars );
             Dau_DsdPrintFromTruth( pTBound, nSSet+nBSet );
             Dau_DsdPrintFromTruth( pTFree,  nSSet+nFSet+1 );
             printf( "Verification failed!\n" );
         }
     }
     return 1;
 }

unsigned If_ManSatCheckXYall	(	void *	pSat,
		int	nLutSize,
		word *	pTruth,
		int	nVars,
		Vec_Int_t *	vLits
	)

Definition at line 476 of file ifSat.c.

 {
     unsigned uSet = If_ManSatCheckXYall_int( pSat, nLutSize, pTruth, nVars, vLits );
 //    Dau_DecPrintSet( uSet, nVars, 1 );
     return uSet;
 }

int If_ManSatDeriveGiaFromBits	(	void *	pGia,
		Ifn_Ntk_t *	p,
		Vec_Int_t *	vValues,
		Vec_Int_t *	vCover
	)

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

Synopsis [Derive GIA using programmable bits.]

Description []

SideEffects []

SeeAlso []

Definition at line 731 of file ifTune.c.

 {
     Gia_Man_t * pNew = (Gia_Man_t *)pGia;
     int i, Id, k, iLit, iVar = 0, nVarsNew, pVarMap[1000];
     assert( Gia_ManCiNum(pNew) == p->nInps && p->nParsVIni < 1000 );
     Gia_ManForEachCiId( pNew, Id, i )
         pVarMap[i] = Abc_Var2Lit( Id, 0 );
     for ( i = p->nInps; i < p->nObjs; i++ )
     {
         int Type = p->Nodes[i].Type;
         int nFans = p->Nodes[i].nFanins;
         int * pFans = p->Nodes[i].Fanins;
         //int iFanin = p->Nodes[i].iFirst;
         assert( nFans <= 6 );
         if ( Type == IFN_DSD_AND )
         {
             iLit = 1;
             for ( k = 0; k < nFans; k++ )
                 iLit = Gia_ManHashAnd( pNew, iLit, pVarMap[pFans[k]] );
             pVarMap[i] = iLit;
         }
         else if ( Type == IFN_DSD_XOR )
         {
             iLit = 0;
             for ( k = 0; k < nFans; k++ )
                 iLit = Gia_ManHashXor( pNew, iLit, pVarMap[pFans[k]] );
             pVarMap[i] = iLit;
         }
         else if ( Type == IFN_DSD_MUX )
         {
             assert( nFans == 3 );
             pVarMap[i] = Gia_ManHashMux( pNew, pVarMap[pFans[0]], pVarMap[pFans[1]], pVarMap[pFans[2]] );
         }
         else if ( Type == IFN_DSD_PRIME )
         {
             int pFaninLits[16];
             // collect truth table
             word uTruth = 0;
             int nMints = (1 << nFans);
             for ( k = 0; k < nMints; k++ )
                 if ( Vec_IntEntry( vValues, iVar++ ) )
                     uTruth |= ((word)1 << k);
             uTruth = Abc_Tt6Stretch( uTruth, nFans );
             // collect function
             for ( k = 0; k < nFans; k++ )
                 pFaninLits[k] = pVarMap[pFans[k]];
             // implement the function
             nVarsNew = Abc_TtMinBase( &uTruth, pFaninLits, nFans, 6 );
             if ( nVarsNew == 0 )
                 pVarMap[i] = (int)(uTruth & 1);
             else
             {
                 extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash );
                 Vec_Int_t Leaves = { nVarsNew, nVarsNew, pFaninLits };
                 pVarMap[i] = Kit_TruthToGia( pNew, (unsigned *)&uTruth, nVarsNew, vCover, &Leaves, 1 ); // hashing enabled!!!
             }
         }
         else assert( 0 );
     }
     assert( iVar == Vec_IntSize(vValues) );
     return pVarMap[p->nObjs - 1];
 }

int If_ManSatFindCofigBits	(	void *	pSat,
		Vec_Int_t *	vPiVars,
		Vec_Int_t *	vPoVars,
		word *	pTruth,
		int	nVars,
		word	Perm,
		int	nInps,
		Vec_Int_t *	vValues
	)

Definition at line 687 of file ifTune.c.

 {
     // extract permutation
     int RetValue, i, pPerm[IF_MAX_FUNC_LUTSIZE];
     assert( nInps <= IF_MAX_FUNC_LUTSIZE );
     for ( i = 0; i < nInps; i++ )
     {
         pPerm[i] = Abc_TtGetHex( &Perm, i );
         assert( pPerm[i] < nVars );
     }
     // perform SAT check 
     RetValue = Ifn_ManSatCheckOne( (sat_solver *)pSat, vPoVars, pTruth, nVars, pPerm, nInps, vValues );
     Vec_IntClear( vValues );
     if ( RetValue == 0 )
         return 0;
     Ifn_ManSatDeriveOne( pSat, vPiVars, vValues );
     return 1;
 }

void If_ManSatUnbuild ( void * p )

Definition at line 85 of file ifSat.c.

 {
     if ( p )
         sat_solver_delete( (sat_solver *)p );
 }

float If_ManScanMapping ( If_Man_t * p )

float If_ManScanMappingDirect ( If_Man_t * p )

float If_ManScanMappingSeq ( If_Man_t * p )

void If_ManSetDefaultPars ( If_Par_t * pPars )

FUNCTION DECLARATIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file ifCore.c.

 {
     memset( pPars, 0, sizeof(If_Par_t) );
     pPars->nLutSize    = -1;
     pPars->nCutsMax    =  8;
     pPars->nFlowIters  =  1;
     pPars->nAreaIters  =  2;
     pPars->DelayTarget = -1;
     pPars->Epsilon     =  (float)0.005;
     pPars->fPreprocess =  1;
     pPars->fArea       =  0;
     pPars->fFancy      =  0;
     pPars->fExpRed     =  1;
     pPars->fLatchPaths =  0;
     pPars->fEdge       =  1;
     pPars->fPower      =  0;
     pPars->fCutMin     =  0;
     pPars->fBidec      =  0;
     pPars->fVerbose    =  0;
 }

void If_ManSetupCiCutSets ( If_Man_t * p )

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

Synopsis [Prepares memory for one cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 548 of file ifMan.c.

 {
     If_Obj_t * pObj;
     int i;
     assert( p->pMemCi == NULL );
     // create elementary cuts for the CIs
     If_ManForEachCi( p, pObj, i )
         If_ManSetupCutTriv( p, &pObj->CutBest, pObj->Id );
     // create elementary cutsets for the CIs
     p->pMemCi = (If_Set_t *)ABC_ALLOC( char, If_ManCiNum(p) * (sizeof(If_Set_t) + sizeof(void *)) );
     If_ManForEachCi( p, pObj, i )
     {
         pObj->pCutSet = (If_Set_t *)((char *)p->pMemCi + i * (sizeof(If_Set_t) + sizeof(void *)));
         pObj->pCutSet->nCuts = 1;
         pObj->pCutSet->nCutsMax = p->pPars->nCutsMax;
         pObj->pCutSet->ppCuts = (If_Cut_t **)(pObj->pCutSet + 1);
         pObj->pCutSet->ppCuts[0] = &pObj->CutBest;
     }
 }

void If_ManSetupCutTriv	(	If_Man_t *	p,
		If_Cut_t *	pCut,
		int	ObjId
	)

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

Synopsis [Prepares memory for one cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 499 of file ifMan.c.

 {
     pCut->fCompl     = 0;
     pCut->nLimit     = p->pPars->nLutSize;
     pCut->nLeaves    = 1;
     pCut->pLeaves[0] = p->pPars->fLiftLeaves? (ObjId << 8) : ObjId;
     pCut->uSign      = If_ObjCutSign( pCut->pLeaves[0] );
     pCut->iCutFunc   = p->pPars->fUseTtPerm ? 3 : (p->pPars->fTruth ? 2: -1);
     pCut->uMaskFunc  = 0;
     assert( pCut->pLeaves[0] < p->vObjs->nSize );
 }

If_Set_t* If_ManSetupNodeCutSet	(	If_Man_t *	p,
		If_Obj_t *	pObj
	)

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

Synopsis [Prepares cutset of the node.]

Description [Elementary cutset will be added last.]

SideEffects []

SeeAlso []

Definition at line 579 of file ifMan.c.

 {
     assert( If_ObjIsAnd(pObj) );
     assert( pObj->pCutSet == NULL );
 //    pObj->pCutSet = (If_Set_t *)Mem_FixedEntryFetch( p->pMemSet );
 //    If_ManSetupSet( p, pObj->pCutSet );
     pObj->pCutSet = If_ManCutSetFetch( p );
     pObj->pCutSet->nCuts = 0;
     pObj->pCutSet->nCutsMax = p->pPars->nCutsMax;
     return pObj->pCutSet;
 }

void If_ManSetupSetAll	(	If_Man_t *	p,
		int	nCrossCut
	)

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

Synopsis [Dereferences cutset of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 675 of file ifMan.c.

 {
     If_Set_t * pCutSet;
     int i, nCutSets;
     nCutSets = 128 + nCrossCut;
     p->pFreeList = p->pMemAnd = pCutSet = (If_Set_t *)ABC_ALLOC( char, nCutSets * p->nSetBytes );
     for ( i = 0; i < nCutSets; i++ )
     {
         If_ManSetupSet( p, pCutSet );
         if ( i == nCutSets - 1 )
             pCutSet->pNext = NULL;
         else
             pCutSet->pNext = (If_Set_t *)( (char *)pCutSet + p->nSetBytes );
         pCutSet = pCutSet->pNext;
     }
     assert( pCutSet == NULL );
 
     if ( p->pPars->fVerbose )
     {
         Abc_Print( 1, "Node = %7d.  Ch = %5d.  Total mem = %7.2f MB. Peak cut mem = %7.2f MB.\n", 
             If_ManAndNum(p), p->nChoices,
             1.0 * (p->nObjBytes + 2*sizeof(void *)) * If_ManObjNum(p) / (1<<20), 
             1.0 * p->nSetBytes * nCrossCut / (1<<20) );
     }
 //    Abc_Print( 1, "Cross cut = %d.\n", nCrossCut );
 
 }

If_Man_t* If_ManStart ( If_Par_t * pPars )

FUNCTION DEFINITIONS ///.

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

Synopsis [Starts the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 50 of file ifMan.c.

 {
     If_Man_t * p; int v;
     assert( !pPars->fUseDsd || !pPars->fUseTtPerm );
     // start the manager
     p = ABC_ALLOC( If_Man_t, 1 );
     memset( p, 0, sizeof(If_Man_t) );
     p->pPars    = pPars;
     p->fEpsilon = pPars->Epsilon;
     // allocate arrays for nodes
     p->vCis     = Vec_PtrAlloc( 100 );
     p->vCos     = Vec_PtrAlloc( 100 );
     p->vObjs    = Vec_PtrAlloc( 100 );
     p->vTemp    = Vec_PtrAlloc( 100 );
     // prepare the memory manager
     if ( p->pPars->fTruth )
     {
         for ( v = 0; v <= p->pPars->nLutSize; v++ )
             p->nTruth6Words[v] = Abc_Truth6WordNum( v );
         for ( v = 6; v <= Abc_MaxInt(6,p->pPars->nLutSize); v++ )
             p->vTtMem[v] = Vec_MemAllocForTT( v, pPars->fUseTtPerm );
         for ( v = 0; v < 6; v++ )
             p->vTtMem[v] = p->vTtMem[6];
         if ( p->pPars->fDelayOpt || pPars->nGateSize > 0 )
         {
             for ( v = 6; v <= Abc_MaxInt(6,p->pPars->nLutSize); v++ )
                 p->vTtIsops[v] = Vec_WecAlloc( 1000 );
             for ( v = 6; v <= Abc_MaxInt(6,p->pPars->nLutSize); v++ )
                 Vec_WecInit( p->vTtIsops[v], 2 );
             for ( v = 0; v < 6; v++ )
                 p->vTtIsops[v] = p->vTtIsops[6];
         }
         if ( pPars->fDelayOpt || pPars->nGateSize > 0 || pPars->fDsdBalance )
         {
             p->vCover = Vec_IntAlloc( 0 );
             p->vArray = Vec_IntAlloc( 1000 );
         }
     }
     p->nPermWords  = p->pPars->fUsePerm? If_CutPermWords( p->pPars->nLutSize ) : 0;
     p->nObjBytes   = sizeof(If_Obj_t) + sizeof(int) * (p->pPars->nLutSize + p->nPermWords);
     p->nCutBytes   = sizeof(If_Cut_t) + sizeof(int) * (p->pPars->nLutSize + p->nPermWords);
     p->nSetBytes   = sizeof(If_Set_t) + (sizeof(If_Cut_t *) + p->nCutBytes) * (p->pPars->nCutsMax + 1);
     p->pMemObj     = Mem_FixedStart( p->nObjBytes );
     // report expected memory usage
     if ( p->pPars->fVerbose )
         Abc_Print( 1, "K = %d. Memory (bytes): Truth = %4d. Cut = %4d. Obj = %4d. Set = %4d. CutMin = %s\n", 
             p->pPars->nLutSize, 8 * p->nTruth6Words[p->pPars->nLutSize], p->nCutBytes, p->nObjBytes, p->nSetBytes, p->pPars->fCutMin? "yes":"no" );
     // room for temporary truth tables
     p->puTemp[0] = p->pPars->fTruth? ABC_ALLOC( unsigned, 8 * p->nTruth6Words[p->pPars->nLutSize] ) : NULL;
     p->puTemp[1] = p->puTemp[0] + p->nTruth6Words[p->pPars->nLutSize]*2;
     p->puTemp[2] = p->puTemp[1] + p->nTruth6Words[p->pPars->nLutSize]*2;
     p->puTemp[3] = p->puTemp[2] + p->nTruth6Words[p->pPars->nLutSize]*2;
     p->puTempW   = p->pPars->fTruth? ABC_ALLOC( word, p->nTruth6Words[p->pPars->nLutSize] ) : NULL;
     if ( pPars->fUseDsd )
     {
         for ( v = 6; v <= Abc_MaxInt(6,p->pPars->nLutSize); v++ )
         {
             p->vTtDsds[v] = Vec_IntAlloc( 1000 );
             Vec_IntPush( p->vTtDsds[v], 0 );
             Vec_IntPush( p->vTtDsds[v], 2 );
             p->vTtPerms[v] = Vec_StrAlloc( 10000 );
             Vec_StrFill( p->vTtPerms[v], 2 * v, IF_BIG_CHAR );
             Vec_StrWriteEntry( p->vTtPerms[v], v, 0 );
         }
         for ( v = 0; v < 6; v++ )
         {
             p->vTtDsds[v]  = p->vTtDsds[6];
             p->vTtPerms[v] = p->vTtPerms[6];
         }
     }
     if ( pPars->fUseTtPerm )
     {
         p->vPairHash = Hash_IntManStart( 10000 );
         p->vPairPerms = Vec_StrAlloc( 10000 );
         Vec_StrFill( p->vPairPerms, p->pPars->nLutSize, 0 );
         p->vPairRes = Vec_IntAlloc( 1000 );
         Vec_IntPush( p->vPairRes, -1 );
     }
     if ( pPars->fUseCofVars )
     {
         for ( v = 6; v <= Abc_MaxInt(6,p->pPars->nLutSize); v++ )
         {
             p->vTtVars[v] = Vec_StrAlloc( 1000 );
             Vec_StrPush( p->vTtVars[v], 0 );
             Vec_StrPush( p->vTtVars[v], 0 );
         }
         for ( v = 0; v < 6; v++ )
             p->vTtVars[v]  = p->vTtVars[6];
     }
     if ( pPars->fUseAndVars )
     {
         for ( v = 6; v <= Abc_MaxInt(6,p->pPars->nLutSize); v++ )
         {
             p->vTtDecs[v] = Vec_IntAlloc( 1000 );
             Vec_IntPush( p->vTtDecs[v], 0 );
             Vec_IntPush( p->vTtDecs[v], 0 );
         }
         for ( v = 0; v < 6; v++ )
             p->vTtDecs[v]  = p->vTtDecs[6];
     }
     if ( pPars->fUseBat )
     {
 //        abctime clk = Abc_Clock();
         extern int Bat_ManCellFuncLookup( void * pMan, unsigned * pTruth, int nVars, int nLeaves, char * pStr );
         extern void Bat_ManFuncSetupTable();
         pPars->pFuncCell = (int (*)  (If_Man_t *, unsigned *, int, int, char *))Bat_ManCellFuncLookup;
         Bat_ManFuncSetupTable();
 //        Abc_PrintTime( 1, "Setup time", Abc_Clock() - clk );
     }
     // create the constant node
     p->pConst1   = If_ManSetupObj( p );
     p->pConst1->Type   = IF_CONST1;
     p->pConst1->fPhase = 1;
     p->nObjs[IF_CONST1]++;
     return p;
 }

void If_ManStop ( If_Man_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 205 of file ifMan.c.

 {
     extern void If_ManCacheAnalize( If_Man_t * p );
     int i;
     if ( p->pPars->fVerbose && p->vCutData )
         If_ManCacheAnalize( p );
     if ( p->pPars->fVerbose && p->pPars->fTruth )
     {
         int nUnique = 0, nMemTotal = 0;
         for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
             nUnique += Vec_MemEntryNum(p->vTtMem[i]);
         for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
             nMemTotal += (int)Vec_MemMemory(p->vTtMem[i]);
         printf( "Unique truth tables = %d   Memory = %.2f MB   ", nUnique, 1.0 * nMemTotal / (1<<20) ); 
         Abc_PrintTime( 1, "Time", p->timeCache[4] );
         if ( p->nCacheMisses )
         {
             printf( "Cache hits = %d. Cache misses = %d  (%.2f %%)\n", p->nCacheHits, p->nCacheMisses, 100.0 * p->nCacheMisses / (p->nCacheHits + p->nCacheMisses) ); 
             Abc_PrintTime( 1, "Non-DSD   ", p->timeCache[0] );
             Abc_PrintTime( 1, "DSD hits  ", p->timeCache[1] );
             Abc_PrintTime( 1, "DSD misses", p->timeCache[2] );
             Abc_PrintTime( 1, "TOTAL     ", p->timeCache[0] + p->timeCache[1] + p->timeCache[2] );
             Abc_PrintTime( 1, "Canon     ", p->timeCache[3] );
         }
     }
     if ( p->pPars->fVerbose && p->nCutsUselessAll )
     {
         for ( i = 0; i <= 16; i++ )
             if ( p->nCutsUseless[i] )
                 Abc_Print( 1, "Useless cuts %2d  = %9d  (out of %9d)  (%6.2f %%)\n", i, p->nCutsUseless[i], p->nCutsCount[i], 100.0*p->nCutsUseless[i]/Abc_MaxInt(p->nCutsCount[i],1) );
         Abc_Print( 1, "Useless cuts all = %9d  (out of %9d)  (%6.2f %%)\n", p->nCutsUselessAll, p->nCutsCountAll, 100.0*p->nCutsUselessAll/Abc_MaxInt(p->nCutsCountAll,1) );
     }
 //    if ( p->pPars->fVerbose && p->nCuts5 )
 //        Abc_Print( 1, "Statistics about 5-cuts: Total = %d  Non-decomposable = %d (%.2f %%)\n", p->nCuts5, p->nCuts5-p->nCuts5a, 100.0*(p->nCuts5-p->nCuts5a)/p->nCuts5 );
     if ( p->pIfDsdMan )
         p->pIfDsdMan = NULL;
     if ( p->pPars->fUseDsd && (p->nCountNonDec[0] || p->nCountNonDec[1]) )
         printf( "NonDec0 = %d.  NonDec1 = %d.\n", p->nCountNonDec[0], p->nCountNonDec[1] );
     Vec_IntFreeP( &p->vCoAttrs );
     Vec_PtrFree( p->vCis );
     Vec_PtrFree( p->vCos );
     Vec_PtrFree( p->vObjs );
     Vec_PtrFree( p->vTemp );
     Vec_IntFreeP( &p->vCover );
     Vec_IntFreeP( &p->vArray );
     Vec_WrdFreeP( &p->vAnds );
     Vec_WrdFreeP( &p->vAndGate );
     Vec_WrdFreeP( &p->vOrGate );
     Vec_PtrFreeP( &p->vObjsRev );
     Vec_PtrFreeP( &p->vLatchOrder );
     Vec_IntFreeP( &p->vLags );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_IntFreeP( &p->vTtDsds[i] );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_StrFreeP( &p->vTtPerms[i] );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_StrFreeP( &p->vTtVars[i] );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_IntFreeP( &p->vTtDecs[i] );
     Vec_IntFreeP( &p->vCutData );
     Vec_IntFreeP( &p->vPairRes );
     Vec_StrFreeP( &p->vPairPerms );
     if ( p->vPairHash )
         Hash_IntManStop( p->vPairHash );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_MemHashFree( p->vTtMem[i] );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_MemFreeP( &p->vTtMem[i] );
     for ( i = 6; i <= Abc_MaxInt(6,p->pPars->nLutSize); i++ )
         Vec_WecFreeP( &p->vTtIsops[i] );
     Mem_FixedStop( p->pMemObj, 0 );
     ABC_FREE( p->pMemCi );
     ABC_FREE( p->pMemAnd );
     ABC_FREE( p->puTemp[0] );
     ABC_FREE( p->puTempW );
     // free pars memory
     ABC_FREE( p->pPars->pTimesArr );
     ABC_FREE( p->pPars->pTimesReq );
     if ( p->pManTim )
         Tim_ManStop( p->pManTim );
     if ( p->vSwitching )
         Vec_IntFree( p->vSwitching );
     if ( p->pPars->fUseBat )
     {
         extern void Bat_ManFuncSetdownTable();
         Bat_ManFuncSetdownTable();
     }
     // hash table
 //    if ( p->pPars->fVerbose && p->nTableEntries[0] )
 //        printf( "Hash table 2:  Entries = %7d.  Size = %7d.\n", p->nTableEntries[0], p->nTableSize[0] );
 //    if ( p->pPars->fVerbose && p->nTableEntries[1] )
 //        printf( "Hash table 3:  Entries = %7d.  Size = %7d.\n", p->nTableEntries[1], p->nTableSize[1] );
     ABC_FREE( p->pHashTable[0] );
     ABC_FREE( p->pHashTable[1] );
     if ( p->pMemEntries )
         Mem_FixedStop( p->pMemEntries, 0 );
     ABC_FREE( p->pName );
     ABC_FREE( p );
 }

static If_Obj_t* If_Not ( If_Obj_t * p )

inlinestatic

Definition at line 356 of file if.h.

356 { return (If_Obj_t *)((ABC_PTRUINT_T)(p) ^ 01); }

Definition: if.h:303

static If_Obj_t* If_NotCond	(	If_Obj_t *	p,
		int	c
	)

inlinestatic

Definition at line 357 of file if.h.

357 { return (If_Obj_t *)((ABC_PTRUINT_T)(p) ^ (c)); }

Definition: if.h:303

static float If_ObjArrTime ( If_Obj_t * pObj )

inlinestatic

Definition at line 405 of file if.h.

405 { return If_ObjCutBest(pObj)->Delay; }

If_ObjCutBest

static If_Cut_t * If_ObjCutBest(If_Obj_t *pObj)

Definition: if.h:401

If_Cut_t_::Delay

float Delay

Definition: if.h:280

static void* If_ObjCopy ( If_Obj_t * pObj )

inlinestatic

Definition at line 384 of file if.h.

384 { return pObj->pCopy; }

If_Obj_t_::pCopy

void * pCopy

Definition: if.h:328

static If_Cut_t* If_ObjCutBest ( If_Obj_t * pObj )

inlinestatic

Definition at line 401 of file if.h.

401 { return &pObj->CutBest; }

If_Obj_t_::CutBest

If_Cut_t CutBest

Definition: if.h:333

static unsigned If_ObjCutSign ( unsigned ObjId )

inlinestatic

Definition at line 402 of file if.h.

402 { return (1 << (ObjId % 31)); }

static unsigned If_ObjCutSignCompute ( If_Cut_t * p )

inlinestatic

Definition at line 403 of file if.h.

403 { unsigned s = 0; int i; for ( i = 0; i < If_CutLeaveNum(p); i++ ) s |= If_ObjCutSign(p->pLeaves[i]); return s; }

If_CutLeaveNum

static int If_CutLeaveNum(If_Cut_t *pCut)

Definition: if.h:390

int pLeaves[0]

Definition: if.h:290

If_ObjCutSign

static unsigned If_ObjCutSign(unsigned ObjId)

Definition: if.h:402

static If_Obj_t* If_ObjFanin0 ( If_Obj_t * pObj )

inlinestatic

Definition at line 380 of file if.h.

380 { return pObj->pFanin0; }

If_Obj_t_::pFanin0

If_Obj_t * pFanin0

Definition: if.h:321

static If_Obj_t* If_ObjFanin1 ( If_Obj_t * pObj )

inlinestatic

Definition at line 381 of file if.h.

381 { return pObj->pFanin1; }

If_Obj_t_::pFanin1

If_Obj_t * pFanin1

Definition: if.h:322

static int If_ObjFaninC0 ( If_Obj_t * pObj )

inlinestatic

Definition at line 382 of file if.h.

382 { return pObj->fCompl0; }

If_Obj_t_::fCompl0

unsigned fCompl0

Definition: if.h:306

static int If_ObjFaninC1 ( If_Obj_t * pObj )

inlinestatic

Definition at line 383 of file if.h.

383 { return pObj->fCompl1; }

If_Obj_t_::fCompl1

unsigned fCompl1

Definition: if.h:307

static int If_ObjId ( If_Obj_t * pObj )

inlinestatic

Definition at line 379 of file if.h.

379 { return pObj->Id; }

If_Obj_t_::Id

int Id

Definition: if.h:316

static int If_ObjIsAnd ( If_Obj_t * pObj )

inlinestatic

Definition at line 377 of file if.h.

377 { return pObj->Type == IF_AND; }

unsigned Type

Definition: if.h:305

IF_AND

Definition: if.h:68

static int If_ObjIsCi ( If_Obj_t * pObj )

inlinestatic

Definition at line 373 of file if.h.

373 { return pObj->Type == IF_CI; }

unsigned Type

Definition: if.h:305

IF_CI

Definition: if.h:66

static int If_ObjIsCo ( If_Obj_t * pObj )

inlinestatic

Definition at line 374 of file if.h.

374 { return pObj->Type == IF_CO; }

unsigned Type

Definition: if.h:305

IF_CO

Definition: if.h:67

static int If_ObjIsConst1 ( If_Obj_t * pObj )

inlinestatic

Definition at line 372 of file if.h.

372 { return pObj->Type == IF_CONST1; }

unsigned Type

Definition: if.h:305

IF_CONST1

Definition: if.h:65

static int If_ObjIsLatch ( If_Obj_t * pObj )

inlinestatic

Definition at line 376 of file if.h.

376 { return If_ObjIsCi(pObj) && pObj->pFanin0 != NULL; }

If_Obj_t_::pFanin0

If_Obj_t * pFanin0

Definition: if.h:321

If_ObjIsCi

static int If_ObjIsCi(If_Obj_t *pObj)

Definition: if.h:373

static int If_ObjIsTerm ( If_Obj_t * pObj )

inlinestatic

Definition at line 375 of file if.h.

375 { return pObj->Type == IF_CI || pObj->Type == IF_CO; }

unsigned Type

Definition: if.h:305

IF_CO

Definition: if.h:67

IF_CI

Definition: if.h:66

static int If_ObjLevel ( If_Obj_t * pObj )

inlinestatic

Definition at line 385 of file if.h.

385 { return pObj->Level; }

If_Obj_t_::Level

unsigned Level

Definition: if.h:315

static float If_ObjLValue ( If_Obj_t * pObj )

inlinestatic

Definition at line 408 of file if.h.

408 { return pObj->LValue; }

If_Obj_t_::LValue

float LValue

Definition: if.h:326

void If_ObjPerformMappingAnd	(	If_Man_t *	p,
		If_Obj_t *	pObj,
		int	Mode,
		int	fPreprocess,
		int	fFirst
	)

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

Synopsis [Finds the best cut for the given node.]

Description [Mapping modes: delay (0), area flow (1), area (2).]

SideEffects []

SeeAlso []

Definition at line 95 of file ifMap.c.

 {
     If_Set_t * pCutSet;
     If_Cut_t * pCut0, * pCut1, * pCut;
     If_Cut_t * pCut0R, * pCut1R;
     int fFunc0R, fFunc1R;
     int i, k, v, iCutDsd, fChange;
     int fSave0 = p->pPars->fDelayOpt || p->pPars->fDelayOptLut || p->pPars->fDsdBalance || p->pPars->fUserRecLib || p->pPars->fUseDsdTune || p->pPars->fUseCofVars || p->pPars->fUseAndVars || p->pPars->pLutStruct != NULL;
     assert( !If_ObjIsAnd(pObj->pFanin0) || pObj->pFanin0->pCutSet->nCuts > 0 );
     assert( !If_ObjIsAnd(pObj->pFanin1) || pObj->pFanin1->pCutSet->nCuts > 0 );
 
     // prepare
     if ( Mode == 0 )
         pObj->EstRefs = (float)pObj->nRefs;
     else if ( Mode == 1 )
         pObj->EstRefs = (float)((2.0 * pObj->EstRefs + pObj->nRefs) / 3.0);
     // deref the selected cut
     if ( Mode && pObj->nRefs > 0 )
         If_CutAreaDeref( p, If_ObjCutBest(pObj) );
 
     // prepare the cutset
     pCutSet = If_ManSetupNodeCutSet( p, pObj );
 
     // get the current assigned best cut
     pCut = If_ObjCutBest(pObj);
     if ( !fFirst )
     {
         // recompute the parameters of the best cut
         if ( p->pPars->fDelayOpt )
             pCut->Delay = If_CutSopBalanceEval( p, pCut, NULL );
         else if ( p->pPars->fDsdBalance )
             pCut->Delay = If_CutDsdBalanceEval( p, pCut, NULL );
         else if ( p->pPars->fUserRecLib )
             pCut->Delay = If_CutDelayRecCost3( p, pCut, pObj ); 
         else if ( p->pPars->fDelayOptLut )
             pCut->Delay = If_CutLutBalanceEval( p, pCut );
         else if( p->pPars->nGateSize > 0 )
             pCut->Delay = If_CutDelaySop( p, pCut );
         else
             pCut->Delay = If_CutDelay( p, pObj, pCut );
         assert( pCut->Delay != -1 );
 //        assert( pCut->Delay <= pObj->Required + p->fEpsilon );
         if ( pCut->Delay > pObj->Required + 2*p->fEpsilon )
             Abc_Print( 1, "If_ObjPerformMappingAnd(): Warning! Delay of node %d (%f) exceeds the required times (%f).\n", 
                 pObj->Id, pCut->Delay, pObj->Required + p->fEpsilon );
         pCut->Area = (Mode == 2)? If_CutAreaDerefed( p, pCut ) : If_CutAreaFlow( p, pCut );
         if ( p->pPars->fEdge )
             pCut->Edge = (Mode == 2)? If_CutEdgeDerefed( p, pCut ) : If_CutEdgeFlow( p, pCut );
         if ( p->pPars->fPower )
             pCut->Power = (Mode == 2)? If_CutPowerDerefed( p, pCut, pObj ) : If_CutPowerFlow( p, pCut, pObj );
         // save the best cut from the previous iteration
         if ( !fPreprocess )
             If_CutCopy( p, pCutSet->ppCuts[pCutSet->nCuts++], pCut );
     }
 
     // generate cuts
     If_ObjForEachCut( pObj->pFanin0, pCut0, i )
     If_ObjForEachCut( pObj->pFanin1, pCut1, k )
     {
         // get the next free cut
         assert( pCutSet->nCuts <= pCutSet->nCutsMax );
         pCut = pCutSet->ppCuts[pCutSet->nCuts];
         // make sure K-feasible cut exists
         if ( If_WordCountOnes(pCut0->uSign | pCut1->uSign) > p->pPars->nLutSize )
             continue;
 
         pCut0R = pCut0;
         pCut1R = pCut1;
         fFunc0R = pCut0->iCutFunc ^ pCut0->fCompl ^ pObj->fCompl0;
         fFunc1R = pCut1->iCutFunc ^ pCut1->fCompl ^ pObj->fCompl1;
         if ( !p->pPars->fUseTtPerm || pCut0->nLeaves > pCut1->nLeaves || (pCut0->nLeaves == pCut1->nLeaves && fFunc0R > fFunc1R) )
         {
         }
         else
         {
             ABC_SWAP( If_Cut_t *, pCut0R, pCut1R );
             ABC_SWAP( int, fFunc0R, fFunc1R );
         }        
 
         // merge the cuts
         if ( p->pPars->fUseTtPerm )
         {
             if ( !If_CutMerge( p, pCut0R, pCut1R, pCut ) )
                 continue;
         }
         else
         {
             if ( !If_CutMergeOrdered( p, pCut0, pCut1, pCut ) )
                 continue;
         }
         if ( pObj->fSpec && pCut->nLeaves == (unsigned)p->pPars->nLutSize )
             continue;
         p->nCutsMerged++;
         p->nCutsTotal++;
         // check if this cut is contained in any of the available cuts
         if ( !p->pPars->fSkipCutFilter && If_CutFilter( pCutSet, pCut, fSave0 ) )
             continue;
         // compute the truth table
         pCut->iCutFunc = -1;
         pCut->fCompl = 0;
         if ( p->pPars->fTruth )
         {
 //            int nShared = pCut0->nLeaves + pCut1->nLeaves - pCut->nLeaves;
             abctime clk = 0;
             if ( p->pPars->fVerbose )
                 clk = Abc_Clock();
             if ( p->pPars->fUseTtPerm )
                 fChange = If_CutComputeTruthPerm( p, pCut, pCut0R, pCut1R, fFunc0R, fFunc1R );
             else
                 fChange = If_CutComputeTruth( p, pCut, pCut0, pCut1, pObj->fCompl0, pObj->fCompl1 );
             if ( p->pPars->fVerbose )
                 p->timeCache[4] += Abc_Clock() - clk;
             if ( !p->pPars->fSkipCutFilter && fChange && If_CutFilter( pCutSet, pCut, fSave0 ) )
                 continue;
             if ( p->pPars->fUseDsd )
             {
                 extern void If_ManCacheRecord( If_Man_t * p, int iDsd0, int iDsd1, int nShared, int iDsd );
                 int truthId = Abc_Lit2Var(pCut->iCutFunc);
                 if ( truthId >= Vec_IntSize(p->vTtDsds[pCut->nLeaves]) || Vec_IntEntry(p->vTtDsds[pCut->nLeaves], truthId) == -1 )
                 {
                     while ( truthId >= Vec_IntSize(p->vTtDsds[pCut->nLeaves]) )
                     {
                         Vec_IntPush( p->vTtDsds[pCut->nLeaves], -1 );
                         for ( v = 0; v < Abc_MaxInt(6, pCut->nLeaves); v++ )
                             Vec_StrPush( p->vTtPerms[pCut->nLeaves], IF_BIG_CHAR );
                     }
                     iCutDsd = If_DsdManCompute( p->pIfDsdMan, If_CutTruthWR(p, pCut), pCut->nLeaves, (unsigned char *)If_CutDsdPerm(p, pCut), p->pPars->pLutStruct );
                     Vec_IntWriteEntry( p->vTtDsds[pCut->nLeaves], truthId, iCutDsd );
                 }
                 assert( If_DsdManSuppSize(p->pIfDsdMan, If_CutDsdLit(p, pCut)) == (int)pCut->nLeaves );
                 //If_ManCacheRecord( p, If_CutDsdLit(p, pCut0), If_CutDsdLit(p, pCut1), nShared, If_CutDsdLit(p, pCut) );
             }
             // run user functions
             pCut->fUseless = 0;
             if ( p->pPars->pFuncCell )
             {
                 assert( p->pPars->fUseTtPerm == 0 );
                 assert( pCut->nLimit >= 4 && pCut->nLimit <= 16 );
                 if ( p->pPars->fUseDsd )
                     pCut->fUseless = If_DsdManCheckDec( p->pIfDsdMan, If_CutDsdLit(p, pCut) );
                 else
                     pCut->fUseless = !p->pPars->pFuncCell( p, If_CutTruth(p, pCut), Abc_MaxInt(6, pCut->nLeaves), pCut->nLeaves, p->pPars->pLutStruct );
                 p->nCutsUselessAll += pCut->fUseless;
                 p->nCutsUseless[pCut->nLeaves] += pCut->fUseless;
                 p->nCutsCountAll++;
                 p->nCutsCount[pCut->nLeaves]++;
                 // skip 5-input cuts, which cannot be decomposed
                 if ( (p->pPars->fEnableCheck75 || p->pPars->fEnableCheck75u) && pCut->nLeaves == 5 && pCut->nLimit == 5 )
                 {
                     extern int If_CluCheckDecInAny( word t, int nVars );
                     extern int If_CluCheckDecOut( word t, int nVars );
                     unsigned TruthU = *If_CutTruth(p, pCut);
                     word Truth = (((word)TruthU << 32) | (word)TruthU);
                     p->nCuts5++;
                     if ( If_CluCheckDecInAny( Truth, 5 ) )
                         p->nCuts5a++;
                     else
                         continue;
                 }
                 else if ( p->pPars->fVerbose && pCut->nLeaves == 5 )
                 {
                     extern int If_CluCheckDecInAny( word t, int nVars );
                     extern int If_CluCheckDecOut( word t, int nVars );
                     unsigned TruthU = *If_CutTruth(p, pCut);
                     word Truth = (((word)TruthU << 32) | (word)TruthU);
                     p->nCuts5++;
                     if ( If_CluCheckDecInAny( Truth, 5 ) || If_CluCheckDecOut( Truth, 5 ) )
                         p->nCuts5a++;
                 }
             }
             else if ( p->pPars->fUseDsdTune )
             {
                 pCut->fUseless = If_DsdManReadMark( p->pIfDsdMan, If_CutDsdLit(p, pCut) );
                 p->nCutsUselessAll += pCut->fUseless;
                 p->nCutsUseless[pCut->nLeaves] += pCut->fUseless;
                 p->nCutsCountAll++;
                 p->nCutsCount[pCut->nLeaves]++;
             }
             else 
             {
                 if ( p->pPars->fUseAndVars )
                 {
                     int iDecMask = -1, truthId = Abc_Lit2Var(pCut->iCutFunc);
                     if ( truthId >= Vec_IntSize(p->vTtDecs[pCut->nLeaves]) || Vec_IntEntry(p->vTtDecs[pCut->nLeaves], truthId) == -1 )
                     {
                         while ( truthId >= Vec_IntSize(p->vTtDecs[pCut->nLeaves]) )
                             Vec_IntPush( p->vTtDecs[pCut->nLeaves], -1 );
                         if ( (int)pCut->nLeaves > p->pPars->nLutSize / 2 )
                             iDecMask = Abc_TtProcessBiDec( If_CutTruthW(p, pCut), (int)pCut->nLeaves, p->pPars->nLutSize / 2 );
                         else
                             iDecMask = 0;
                         Vec_IntWriteEntry( p->vTtDecs[pCut->nLeaves], truthId, iDecMask );
                     }
                     iDecMask = Vec_IntEntry(p->vTtDecs[pCut->nLeaves], truthId);
                     assert( iDecMask >= 0 );
                     pCut->fUseless = (int)(iDecMask == 0 && (int)pCut->nLeaves > p->pPars->nLutSize / 2);
                     p->nCutsUselessAll += pCut->fUseless;
                     p->nCutsUseless[pCut->nLeaves] += pCut->fUseless;
                     p->nCutsCountAll++;
                     p->nCutsCount[pCut->nLeaves]++;
                 }
                 if ( p->pPars->fUseCofVars && (!p->pPars->fUseAndVars || pCut->fUseless) )
                 {
                     int iCofVar = -1, truthId = Abc_Lit2Var(pCut->iCutFunc);
                     if ( truthId >= Vec_StrSize(p->vTtVars[pCut->nLeaves]) || Vec_StrEntry(p->vTtVars[pCut->nLeaves], truthId) == (char)-1 )
                     {
                         while ( truthId >= Vec_StrSize(p->vTtVars[pCut->nLeaves]) )
                             Vec_StrPush( p->vTtVars[pCut->nLeaves], (char)-1 );
                         iCofVar = Abc_TtCheckCondDep( If_CutTruthWR(p, pCut), pCut->nLeaves, p->pPars->nLutSize / 2 );
                         Vec_StrWriteEntry( p->vTtVars[pCut->nLeaves], truthId, (char)iCofVar );
                     }
                     iCofVar = Vec_StrEntry(p->vTtVars[pCut->nLeaves], truthId);
                     assert( iCofVar >= 0 && iCofVar <= (int)pCut->nLeaves );
                     pCut->fUseless = (int)(iCofVar == (int)pCut->nLeaves && pCut->nLeaves > 0);
                     p->nCutsUselessAll += pCut->fUseless;
                     p->nCutsUseless[pCut->nLeaves] += pCut->fUseless;
                     p->nCutsCountAll++;
                     p->nCutsCount[pCut->nLeaves]++;
                 }
             }
         }
         
         // compute the application-specific cost and depth
         pCut->fUser = (p->pPars->pFuncCost != NULL);
         pCut->Cost = p->pPars->pFuncCost? p->pPars->pFuncCost(p, pCut) : 0;
         if ( pCut->Cost == IF_COST_MAX )
             continue;
         // check if the cut satisfies the required times
         if ( p->pPars->fDelayOpt )
         {
             pCut->Delay = If_CutSopBalanceEval( p, pCut, NULL );
 //            if ( pCut->Delay >= pObj->Level && pCut->nLeaves > 2 )
 //                pCut->Delay += 1;
         }
         else if ( p->pPars->fDsdBalance )
         {
             pCut->Delay = If_CutDsdBalanceEval( p, pCut, NULL );
 //            if ( pCut->Delay >= pObj->Level && pCut->nLeaves > 2 )
 //                pCut->Delay += 1;
         }
         else if ( p->pPars->fUserRecLib )
         {
             pCut->Delay = If_CutDelayRecCost3( p, pCut, pObj ); 
 //            if ( pCut->Delay >= pObj->Level && pCut->nLeaves > 2 )
 //                pCut->Delay += 1;
         }
         else if ( p->pPars->fDelayOptLut )
             pCut->Delay = If_CutLutBalanceEval( p, pCut );
         else if( p->pPars->nGateSize > 0 )
             pCut->Delay = If_CutDelaySop( p, pCut );
         else 
             pCut->Delay = If_CutDelay( p, pObj, pCut );
         if ( pCut->Delay == -1 )
             continue;
         if ( Mode && pCut->Delay > pObj->Required + p->fEpsilon )
             continue;
         // compute area of the cut (this area may depend on the application specific cost)
         pCut->Area = (Mode == 2)? If_CutAreaDerefed( p, pCut ) : If_CutAreaFlow( p, pCut );
         if ( p->pPars->fEdge )
             pCut->Edge = (Mode == 2)? If_CutEdgeDerefed( p, pCut ) : If_CutEdgeFlow( p, pCut );
         if ( p->pPars->fPower )
             pCut->Power = (Mode == 2)? If_CutPowerDerefed( p, pCut, pObj ) : If_CutPowerFlow( p, pCut, pObj );
 //        pCut->AveRefs = (Mode == 0)? (float)0.0 : If_CutAverageRefs( p, pCut );
         // insert the cut into storage
         If_CutSort( p, pCutSet, pCut );
 //        If_CutTraverse( p, pObj, pCut );
     } 
     assert( pCutSet->nCuts > 0 );
 //    If_CutVerifyCuts( pCutSet, !p->pPars->fUseTtPerm );
 
     // update the best cut
     if ( !fPreprocess || pCutSet->ppCuts[0]->Delay <= pObj->Required + p->fEpsilon )
     {
         If_CutCopy( p, If_ObjCutBest(pObj), pCutSet->ppCuts[0] );
         if(p->pPars->fUserRecLib)
             assert(If_ObjCutBest(pObj)->Cost < IF_COST_MAX && If_ObjCutBest(pObj)->Delay < ABC_INFINITY);
     }
     // add the trivial cut to the set
     if ( !pObj->fSkipCut && If_ObjCutBest(pObj)->nLeaves > 1 )
     {
         If_ManSetupCutTriv( p, pCutSet->ppCuts[pCutSet->nCuts++], pObj->Id );
         assert( pCutSet->nCuts <= pCutSet->nCutsMax+1 );
     }
 //    if ( If_ObjCutBest(pObj)->nLeaves == 0 )
 //        p->nBestCutSmall[0]++;
 //    else if ( If_ObjCutBest(pObj)->nLeaves == 1 )
 //        p->nBestCutSmall[1]++;
 
     // ref the selected cut
     if ( Mode && pObj->nRefs > 0 )
         If_CutAreaRef( p, If_ObjCutBest(pObj) );
     if ( If_ObjCutBest(pObj)->fUseless )
         Abc_Print( 1, "The best cut is useless.\n" );
     // call the user specified function for each cut
     if ( p->pPars->pFuncUser )
         If_ObjForEachCut( pObj, pCut, i )
             p->pPars->pFuncUser( p, pObj, pCut );
     // free the cuts
     If_ManDerefNodeCutSet( p, pObj );
 }

void If_ObjPerformMappingChoice	(	If_Man_t *	p,
		If_Obj_t *	pObj,
		int	Mode,
		int	fPreprocess
	)

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

Synopsis [Finds the best cut for the choice node.]

Description []

SideEffects []

SeeAlso []

Definition at line 407 of file ifMap.c.

 {
     If_Set_t * pCutSet;
     If_Obj_t * pTemp;
     If_Cut_t * pCutTemp, * pCut;
     int i, fSave0 = p->pPars->fDelayOpt || p->pPars->fDelayOptLut || p->pPars->fDsdBalance || p->pPars->fUserRecLib;
     assert( pObj->pEquiv != NULL );
 
     // prepare
     if ( Mode && pObj->nRefs > 0 )
         If_CutAreaDeref( p, If_ObjCutBest(pObj) );
 
     // remove elementary cuts
     for ( pTemp = pObj; pTemp; pTemp = pTemp->pEquiv )
         pTemp->pCutSet->nCuts--;
 
     // update the cutset of the node
     pCutSet = pObj->pCutSet;
 
     // generate cuts
     for ( pTemp = pObj->pEquiv; pTemp; pTemp = pTemp->pEquiv )
     {
         if ( pTemp->pCutSet->nCuts == 0 )
             continue;
         // go through the cuts of this node
         If_ObjForEachCut( pTemp, pCutTemp, i )
         {
             if ( pCutTemp->fUseless )
                 continue;
             // get the next free cut
             assert( pCutSet->nCuts <= pCutSet->nCutsMax );
             pCut = pCutSet->ppCuts[pCutSet->nCuts];
             // copy the cut into storage
             If_CutCopy( p, pCut, pCutTemp );
             // check if this cut is contained in any of the available cuts
             if ( If_CutFilter( pCutSet, pCut, fSave0 ) )
                 continue;
             // check if the cut satisfies the required times
 //            assert( pCut->Delay == If_CutDelay( p, pTemp, pCut ) );
             if ( Mode && pCut->Delay > pObj->Required + p->fEpsilon )
                 continue;
             // set the phase attribute
             pCut->fCompl = pObj->fPhase ^ pTemp->fPhase;
             // compute area of the cut (this area may depend on the application specific cost)
             pCut->Area = (Mode == 2)? If_CutAreaDerefed( p, pCut ) : If_CutAreaFlow( p, pCut );
             if ( p->pPars->fEdge )
                 pCut->Edge = (Mode == 2)? If_CutEdgeDerefed( p, pCut ) : If_CutEdgeFlow( p, pCut );
             if ( p->pPars->fPower )
                 pCut->Power = (Mode == 2)? If_CutPowerDerefed( p, pCut, pObj ) : If_CutPowerFlow( p, pCut, pObj );
 //            pCut->AveRefs = (Mode == 0)? (float)0.0 : If_CutAverageRefs( p, pCut );
             // insert the cut into storage
             If_CutSort( p, pCutSet, pCut );
         }
     } 
     assert( pCutSet->nCuts > 0 );
 
     // update the best cut
     if ( !fPreprocess || pCutSet->ppCuts[0]->Delay <= pObj->Required + p->fEpsilon )
         If_CutCopy( p, If_ObjCutBest(pObj), pCutSet->ppCuts[0] );
     // add the trivial cut to the set
     if ( !pObj->fSkipCut && If_ObjCutBest(pObj)->nLeaves > 1 )
     {
         If_ManSetupCutTriv( p, pCutSet->ppCuts[pCutSet->nCuts++], pObj->Id );
         assert( pCutSet->nCuts <= pCutSet->nCutsMax+1 );
     }
 
     // ref the selected cut
     if ( Mode && pObj->nRefs > 0 )
         If_CutAreaRef( p, If_ObjCutBest(pObj) );
     // free the cuts
     If_ManDerefChoiceCutSet( p, pObj );
 }

void If_ObjPrint ( If_Obj_t * pObj )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 604 of file ifUtil.c.

 {
     if ( pObj == NULL )
     {
         printf( "Object is NULL." );
         return;
     }
     printf( "Obj %4d : ", If_ObjId(pObj) );
     if ( If_ObjIsConst1(pObj) )
         printf( "constant 1" );
     else if ( If_ObjIsCi(pObj) )
         printf( "PI" );
     else if ( If_ObjIsCo(pObj) )
         printf( "PO( %4d%s )", If_ObjId(If_ObjFanin0(pObj)), (If_ObjFaninC0(pObj)? "\'" : " ") );
     else
         printf( "AND( %4d%s, %4d%s )", 
             If_ObjId(If_ObjFanin0(pObj)), (If_ObjFaninC0(pObj)? "\'" : " "), 
             If_ObjId(If_ObjFanin1(pObj)), (If_ObjFaninC1(pObj)? "\'" : " ") );
     printf( " (refs = %3d)", pObj->nVisitsCopy );
     printf( "\n" );
 }

static void If_ObjSetArrTime	(	If_Obj_t *	pObj,
		float	ArrTime
	)

inlinestatic

Definition at line 406 of file if.h.

406 { If_ObjCutBest(pObj)->Delay = ArrTime; }

If_ObjCutBest

static If_Cut_t * If_ObjCutBest(If_Obj_t *pObj)

Definition: if.h:401

If_Cut_t_::Delay

float Delay

Definition: if.h:280

static void If_ObjSetChoice	(	If_Obj_t *	pObj,
		If_Obj_t *	pEqu
	)

inlinestatic

Definition at line 388 of file if.h.

388 { pObj->pEquiv = pEqu; }

If_Obj_t_::pEquiv

If_Obj_t * pEquiv

Definition: if.h:323

static void If_ObjSetCopy	(	If_Obj_t *	pObj,
		void *	pCopy
	)

inlinestatic

Definition at line 387 of file if.h.

387 { pObj->pCopy = pCopy; }

If_Obj_t_::pCopy

void * pCopy

Definition: if.h:328

static void If_ObjSetLevel	(	If_Obj_t *	pObj,
		int	Level
	)

inlinestatic

Definition at line 386 of file if.h.

386 { pObj->Level = Level; }

If_Obj_t_::Level

unsigned Level

Definition: if.h:315

static void If_ObjSetLValue	(	If_Obj_t *	pObj,
		float	LValue
	)

inlinestatic

Definition at line 409 of file if.h.

409 { pObj->LValue = LValue; }

If_Obj_t_::LValue

float LValue

Definition: if.h:326

static If_Obj_t* If_Regular ( If_Obj_t * p )

inlinestatic

Definition at line 355 of file if.h.

355 { return (If_Obj_t *)((ABC_PTRUINT_T)(p) & ~01); }