luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Improvements to technology mapping.

This commit is contained in:
Alan Mishchenko 2014-04-02 19:33:49 -07:00
parent b085ba4b51
commit 280a485336
3 changed files with 57 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/map/if/if.h
View File

@ -216,7 +216,7 @@ struct If_Man_t_
int nMaxIters; // the maximum number of iterations int nMaxIters; // the maximum number of iterations
int Period; // the current value of the clock period (for seq mapping) int Period; // the current value of the clock period (for seq mapping)
// memory management // memory management
int nTruth6Words; // the size of the truth table if allocated int nTruth6Words[IF_MAX_FUNC_LUTSIZE+1]; // the size of the truth table if allocated
int nPermWords; // the size of the permutation array (in words) int nPermWords; // the size of the permutation array (in words)
int nObjBytes; // the size of the object int nObjBytes; // the size of the object
int nCutBytes; // the size of the cut int nCutBytes; // the size of the cut
@ -234,7 +234,7 @@ struct If_Man_t_
int nCutsUselessAll; int nCutsUselessAll;
int nCuts5, nCuts5a; int nCuts5, nCuts5a;
If_DsdMan_t * pIfDsdMan; If_DsdMan_t * pIfDsdMan;
Vec_Mem_t * vTtMem; // truth table memory and hash table Vec_Mem_t * vTtMem[IF_MAX_FUNC_LUTSIZE+1]; // truth table memory and hash table
Vec_Int_t * vTtDsds; // mapping of truth table into DSD Vec_Int_t * vTtDsds; // mapping of truth table into DSD
Vec_Str_t * vTtPerms; // mapping of truth table into permutations Vec_Str_t * vTtPerms; // mapping of truth table into permutations
Hash_IntMan_t * vPairHash; // hashing pairs of truth tables Hash_IntMan_t * vPairHash; // hashing pairs of truth tables
@ -406,10 +406,10 @@ static inline void If_CutSetData( If_Cut_t * pCut, void * pData ) { *
static inline int If_CutDataInt( If_Cut_t * pCut ) { return *(int *)pCut; } static inline int If_CutDataInt( If_Cut_t * pCut ) { return *(int *)pCut; }
static inline void If_CutSetDataInt( If_Cut_t * pCut, int Data ) { *(int *)pCut = Data; } static inline void If_CutSetDataInt( If_Cut_t * pCut, int Data ) { *(int *)pCut = Data; }
static inline word * If_CutTruthWR( If_Man_t * p, If_Cut_t * pCut ) { return p->vTtMem ? Vec_MemReadEntry(p->vTtMem, Abc_Lit2Var(pCut->iCutFunc)) : NULL; } static inline word * If_CutTruthWR( If_Man_t * p, If_Cut_t * pCut ) { return p->vTtMem ? Vec_MemReadEntry(p->vTtMem[pCut->nLeaves], Abc_Lit2Var(pCut->iCutFunc)) : NULL; }
static inline unsigned * If_CutTruthR( If_Man_t * p, If_Cut_t * pCut ) { return (unsigned *)If_CutTruthWR(p, pCut); } static inline unsigned * If_CutTruthR( If_Man_t * p, If_Cut_t * pCut ) { return (unsigned *)If_CutTruthWR(p, pCut); }
static inline int If_CutTruthIsCompl( If_Cut_t * pCut ) { assert( pCut->iCutFunc >= 0 ); return Abc_LitIsCompl(pCut->iCutFunc); } static inline int If_CutTruthIsCompl( If_Cut_t * pCut ) { assert( pCut->iCutFunc >= 0 ); return Abc_LitIsCompl(pCut->iCutFunc); }
static inline word * If_CutTruthW( If_Man_t * p, If_Cut_t * pCut ) { if ( p->vTtMem == NULL ) return NULL; assert( pCut->iCutFunc >= 0 ); Abc_TtCopy( p->puTempW, If_CutTruthWR(p, pCut), p->nTruth6Words, If_CutTruthIsCompl(pCut) ); return p->puTempW; } static inline word * If_CutTruthW( If_Man_t * p, If_Cut_t * pCut ) { 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; }
static inline unsigned * If_CutTruth( If_Man_t * p, If_Cut_t * pCut ) { return (unsigned *)If_CutTruthW(p, pCut); } static inline unsigned * If_CutTruth( If_Man_t * p, If_Cut_t * pCut ) { return (unsigned *)If_CutTruthW(p, pCut); }
static inline float If_CutLutArea( If_Man_t * p, If_Cut_t * pCut ) { return pCut->fUser? (float)pCut->Cost : (p->pPars->pLutLib? p->pPars->pLutLib->pLutAreas[pCut->nLeaves] : (float)1.0); } static inline float If_CutLutArea( If_Man_t * p, If_Cut_t * pCut ) { return pCut->fUser? (float)pCut->Cost : (p->pPars->pLutLib? p->pPars->pLutLib->pLutAreas[pCut->nLeaves] : (float)1.0); }

49
src/map/if/ifMan.c
View File

@ -51,7 +51,7 @@ extern abctime s_TimeComp[4];
***********************************************************************/ ***********************************************************************/
If_Man_t * If_ManStart( If_Par_t * pPars ) If_Man_t * If_ManStart( If_Par_t * pPars )
{ {
If_Man_t * p; If_Man_t * p; int v;
assert( !pPars->fUseDsd || !pPars->fUseTtPerm ); assert( !pPars->fUseDsd || !pPars->fUseTtPerm );
// start the manager // start the manager
p = ABC_ALLOC( If_Man_t, 1 ); p = ABC_ALLOC( If_Man_t, 1 );
@ -65,9 +65,15 @@ If_Man_t * If_ManStart( If_Par_t * pPars )
// p->vMapped = Vec_PtrAlloc( 100 ); // p->vMapped = Vec_PtrAlloc( 100 );
p->vTemp = Vec_PtrAlloc( 100 ); p->vTemp = Vec_PtrAlloc( 100 );
// prepare the memory manager // prepare the memory manager
p->vTtMem = p->pPars->fTruth? Vec_MemAllocForTT( p->pPars->nLutSize ) : NULL; if ( p->pPars->fTruth )
p->nTruth6Words= p->pPars->fTruth? Abc_Truth6WordNum( p->pPars->nLutSize ) : 0; {
// p->nTruthWords = p->pPars->fTruth? If_CutTruthWords( p->pPars->nLutSize ) : 0; for ( v = 0; v <= p->pPars->nLutSize; v++ )
p->nTruth6Words[v] = Abc_Truth6WordNum( v );
for ( v = 6; v <= p->pPars->nLutSize; v++ )
p->vTtMem[v] = Vec_MemAllocForTT( v );
for ( v = 0; v < 6; v++ )
p->vTtMem[v] = p->vTtMem[6];
}
p->nPermWords = p->pPars->fUsePerm? If_CutPermWords( p->pPars->nLutSize ) : 0; 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->nTruthWords*/); p->nObjBytes = sizeof(If_Obj_t) + sizeof(int) * (p->pPars->nLutSize + p->nPermWords/* + p->nTruthWords*/);
p->nCutBytes = sizeof(If_Cut_t) + sizeof(int) * (p->pPars->nLutSize + p->nPermWords/* + p->nTruthWords*/); p->nCutBytes = sizeof(If_Cut_t) + sizeof(int) * (p->pPars->nLutSize + p->nPermWords/* + p->nTruthWords*/);
@ -77,13 +83,13 @@ If_Man_t * If_ManStart( If_Par_t * pPars )
// report expected memory usage // report expected memory usage
if ( p->pPars->fVerbose ) if ( p->pPars->fVerbose )
Abc_Print( 1, "K = %d. Memory (bytes): Truth = %4d. Cut = %4d. Obj = %4d. Set = %4d. CutMin = %s\n", 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->nCutBytes, p->nObjBytes, p->nSetBytes, p->pPars->fCutMin? "yes":"no" ); 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 // room for temporary truth tables
p->puTemp[0] = p->pPars->fTruth? ABC_ALLOC( unsigned, 8 * p->nTruth6Words ) : NULL; p->puTemp[0] = p->pPars->fTruth? ABC_ALLOC( unsigned, 8 * p->nTruth6Words[p->pPars->nLutSize] ) : NULL;
p->puTemp[1] = p->puTemp[0] + p->nTruth6Words*2; p->puTemp[1] = p->puTemp[0] + p->nTruth6Words[p->pPars->nLutSize]*2;
p->puTemp[2] = p->puTemp[1] + p->nTruth6Words*2; p->puTemp[2] = p->puTemp[1] + p->nTruth6Words[p->pPars->nLutSize]*2;
p->puTemp[3] = p->puTemp[2] + p->nTruth6Words*2; p->puTemp[3] = p->puTemp[2] + p->nTruth6Words[p->pPars->nLutSize]*2;
p->puTempW = p->pPars->fTruth? ABC_ALLOC( word, p->nTruth6Words ) : NULL; p->puTempW = p->pPars->fTruth? ABC_ALLOC( word, p->nTruth6Words[p->pPars->nLutSize] ) : NULL;
if ( pPars->fUseDsd ) if ( pPars->fUseDsd )
{ {
p->vTtDsds = Vec_IntAlloc( 1000 ); p->vTtDsds = Vec_IntAlloc( 1000 );
@ -95,10 +101,6 @@ If_Man_t * If_ManStart( If_Par_t * pPars )
} }
if ( pPars->fUseTtPerm ) if ( pPars->fUseTtPerm )
{ {
word uTruth = 0;
Vec_MemHashInsert( p->vTtMem, &uTruth );
uTruth = ABC_CONST(0xAAAAAAAAAAAAAAAA);
Vec_MemHashInsert( p->vTtMem, &uTruth );
p->vPairHash = Hash_IntManStart( 10000 ); p->vPairHash = Hash_IntManStart( 10000 );
p->vTtPerms = Vec_StrAlloc( 10000 ); p->vTtPerms = Vec_StrAlloc( 10000 );
} }
@ -152,13 +154,20 @@ void If_ManRestart( If_Man_t * p )
void If_ManStop( If_Man_t * p ) void If_ManStop( If_Man_t * p )
{ {
extern void If_ManCacheAnalize( If_Man_t * p ); extern void If_ManCacheAnalize( If_Man_t * p );
int i;
if ( p->pPars->fVerbose && p->vCutData ) if ( p->pPars->fVerbose && p->vCutData )
If_ManCacheAnalize( p ); If_ManCacheAnalize( p );
if ( p->pPars->fVerbose && p->vTtMem ) if ( p->pPars->fVerbose && p->pPars->fTruth )
printf( "Unique truth tables = %d. Memory = %.2f MB\n", Vec_MemEntryNum(p->vTtMem), Vec_MemMemory(p->vTtMem) / (1<<20) ); {
int nUnique = 0, nMemTotal = 0;
for ( i = 6; i <= p->pPars->nLutSize; i++ )
nUnique += Vec_MemEntryNum(p->vTtMem[i]);
for ( i = 6; i <= p->pPars->nLutSize; i++ )
nMemTotal += (int)Vec_MemMemory(p->vTtMem[i]);
printf( "Unique truth tables = %d. Memory = %.2f MB\n", nUnique, 1.0 * nMemTotal / (1<<20) );
}
if ( p->pPars->fVerbose && p->nCutsUselessAll ) if ( p->pPars->fVerbose && p->nCutsUselessAll )
{ {
int i;
for ( i = 0; i <= 16; i++ ) for ( i = 0; i <= 16; i++ )
if ( p->nCutsUseless[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]/(p->nCutsCount[i]+1) ); 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]/(p->nCutsCount[i]+1) );
@ -189,8 +198,10 @@ void If_ManStop( If_Man_t * p )
Vec_IntFreeP( &p->vCutData ); Vec_IntFreeP( &p->vCutData );
if ( p->vPairHash ) if ( p->vPairHash )
Hash_IntManStop( p->vPairHash ); Hash_IntManStop( p->vPairHash );
Vec_MemHashFree( p->vTtMem ); for ( i = 6; i <= p->pPars->nLutSize; i++ )
Vec_MemFreeP( &p->vTtMem ); Vec_MemHashFree( p->vTtMem[i] );
for ( i = 6; i <= p->pPars->nLutSize; i++ )
Vec_MemFreeP( &p->vTtMem[i] );
Mem_FixedStop( p->pMemObj, 0 ); Mem_FixedStop( p->pMemObj, 0 );
ABC_FREE( p->pMemCi ); ABC_FREE( p->pMemCi );
ABC_FREE( p->pMemAnd ); ABC_FREE( p->pMemAnd );

43
src/map/if/ifTruth.c
View File

@ -71,14 +71,14 @@ void If_CutRotatePins( If_Man_t * p, If_Cut_t * pCut )
assert( !p->pPars->fUseTtPerm ); assert( !p->pPars->fUseTtPerm );
If_CutForEachLeaf( p, pCut, pLeaf, i ) If_CutForEachLeaf( p, pCut, pLeaf, i )
PinDelays[i] = If_ObjCutBest(pLeaf)->Delay; PinDelays[i] = If_ObjCutBest(pLeaf)->Delay;
if ( p->vTtMem == NULL ) if ( p->vTtMem[pCut->nLeaves] == NULL )
{ {
If_CutTruthPermute( NULL, If_CutLeaveNum(pCut), pCut->nLimit, p->nTruth6Words, PinDelays, If_CutLeaves(pCut) ); If_CutTruthPermute( NULL, If_CutLeaveNum(pCut), pCut->nLeaves, p->nTruth6Words[pCut->nLeaves], PinDelays, If_CutLeaves(pCut) );
return; return;
} }
Abc_TtCopy( p->puTempW, If_CutTruthWR(p, pCut), p->nTruth6Words, 0 ); Abc_TtCopy( p->puTempW, If_CutTruthWR(p, pCut), p->nTruth6Words[pCut->nLeaves], 0 );
If_CutTruthPermute( p->puTempW, If_CutLeaveNum(pCut), pCut->nLimit, p->nTruth6Words, PinDelays, If_CutLeaves(pCut) ); If_CutTruthPermute( p->puTempW, If_CutLeaveNum(pCut), pCut->nLeaves, p->nTruth6Words[pCut->nLeaves], PinDelays, If_CutLeaves(pCut) );
truthId = Vec_MemHashInsert( p->vTtMem, p->puTempW ); truthId = Vec_MemHashInsert( p->vTtMem[pCut->nLeaves], p->puTempW );
pCut->iCutFunc = Abc_Var2Lit( truthId, If_CutTruthIsCompl(pCut) ); pCut->iCutFunc = Abc_Var2Lit( truthId, If_CutTruthIsCompl(pCut) );
assert( (p->puTempW[0] & 1) == 0 ); assert( (p->puTempW[0] & 1) == 0 );
} }
@ -97,21 +97,23 @@ void If_CutRotatePins( If_Man_t * p, If_Cut_t * pCut )
int If_CutComputeTruth( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 ) int If_CutComputeTruth( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 )
{ {
int fCompl, truthId, nLeavesNew, RetValue = 0; int fCompl, truthId, nLeavesNew, RetValue = 0;
int nWords = Abc_TtWordNum( pCut->nLimit ); int nWords = Abc_TtWordNum( pCut->nLeaves );
word * pTruth0s = Vec_MemReadEntry( p->vTtMem, Abc_Lit2Var(pCut0->iCutFunc) ); word * pTruth0s = Vec_MemReadEntry( p->vTtMem[pCut0->nLeaves], Abc_Lit2Var(pCut0->iCutFunc) );
word * pTruth1s = Vec_MemReadEntry( p->vTtMem, Abc_Lit2Var(pCut1->iCutFunc) ); word * pTruth1s = Vec_MemReadEntry( p->vTtMem[pCut1->nLeaves], Abc_Lit2Var(pCut1->iCutFunc) );
word * pTruth0 = (word *)p->puTemp[0]; word * pTruth0 = (word *)p->puTemp[0];
word * pTruth1 = (word *)p->puTemp[1]; word * pTruth1 = (word *)p->puTemp[1];
word * pTruth = (word *)p->puTemp[2]; word * pTruth = (word *)p->puTemp[2];
Abc_TtCopy( pTruth0, pTruth0s, nWords, fCompl0 ^ pCut0->fCompl ^ Abc_LitIsCompl(pCut0->iCutFunc) ); Abc_TtCopy( pTruth0, pTruth0s, nWords, fCompl0 ^ pCut0->fCompl ^ Abc_LitIsCompl(pCut0->iCutFunc) );
Abc_TtCopy( pTruth1, pTruth1s, nWords, fCompl1 ^ pCut1->fCompl ^ Abc_LitIsCompl(pCut1->iCutFunc) ); Abc_TtCopy( pTruth1, pTruth1s, nWords, fCompl1 ^ pCut1->fCompl ^ Abc_LitIsCompl(pCut1->iCutFunc) );
Abc_TtStretch( pTruth0, pCut->nLimit, pCut0->pLeaves, pCut0->nLeaves, pCut->pLeaves, pCut->nLeaves ); Abc_TtStretch6( pTruth0, pCut0->nLeaves, pCut->nLeaves );
Abc_TtStretch( pTruth1, pCut->nLimit, pCut1->pLeaves, pCut1->nLeaves, pCut->pLeaves, pCut->nLeaves ); Abc_TtStretch6( pTruth1, pCut1->nLeaves, pCut->nLeaves );
Abc_TtStretch( pTruth0, pCut->nLeaves, pCut0->pLeaves, pCut0->nLeaves, pCut->pLeaves, pCut->nLeaves );
Abc_TtStretch( pTruth1, pCut->nLeaves, pCut1->pLeaves, pCut1->nLeaves, pCut->pLeaves, pCut->nLeaves );
fCompl = (pTruth0[0] & pTruth1[0] & 1); fCompl = (pTruth0[0] & pTruth1[0] & 1);
Abc_TtAnd( pTruth, pTruth0, pTruth1, nWords, fCompl ); Abc_TtAnd( pTruth, pTruth0, pTruth1, nWords, fCompl );
if ( p->pPars->fCutMin ) if ( p->pPars->fCutMin )
{ {
nLeavesNew = Abc_TtMinBase( pTruth, pCut->pLeaves, pCut->nLeaves, pCut->nLimit ); nLeavesNew = Abc_TtMinBase( pTruth, pCut->pLeaves, pCut->nLeaves, pCut->nLeaves );
if ( nLeavesNew < If_CutLeaveNum(pCut) ) if ( nLeavesNew < If_CutLeaveNum(pCut) )
{ {
pCut->nLeaves = nLeavesNew; pCut->nLeaves = nLeavesNew;
@ -119,7 +121,7 @@ int If_CutComputeTruth( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_
RetValue = 1; RetValue = 1;
} }
} }
truthId = Vec_MemHashInsert( p->vTtMem, pTruth ); truthId = Vec_MemHashInsert( p->vTtMem[pCut->nLeaves], pTruth );
pCut->iCutFunc = Abc_Var2Lit( truthId, fCompl ); pCut->iCutFunc = Abc_Var2Lit( truthId, fCompl );
assert( (pTruth[0] & 1) == 0 ); assert( (pTruth[0] & 1) == 0 );
#ifdef IF_TRY_NEW #ifdef IF_TRY_NEW
@ -127,7 +129,7 @@ int If_CutComputeTruth( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_
word pCopy[1024]; word pCopy[1024];
char pCanonPerm[16]; char pCanonPerm[16];
memcpy( pCopy, If_CutTruthW(pCut), sizeof(word) * nWords ); memcpy( pCopy, If_CutTruthW(pCut), sizeof(word) * nWords );
Abc_TtCanonicize( pCopy, pCut->nLimit, pCanonPerm ); Abc_TtCanonicize( pCopy, pCut->nLeaves, pCanonPerm );
} }
#endif #endif
return RetValue; return RetValue;
@ -150,9 +152,9 @@ int If_CutComputeTruthPerm( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_
int pPerm[IF_MAX_LUTSIZE]; int pPerm[IF_MAX_LUTSIZE];
char pCanonPerm[IF_MAX_LUTSIZE]; char pCanonPerm[IF_MAX_LUTSIZE];
int v, Place, fCompl, truthId, nLeavesNew, uCanonPhase, RetValue = 0; int v, Place, fCompl, truthId, nLeavesNew, uCanonPhase, RetValue = 0;
int nWords = Abc_TtWordNum( pCut->nLimit ); int nWords = Abc_TtWordNum( pCut->nLeaves );
word * pTruth0s = Vec_MemReadEntry( p->vTtMem, Abc_Lit2Var(pCut0->iCutFunc) ); word * pTruth0s = Vec_MemReadEntry( p->vTtMem[pCut0->nLeaves], Abc_Lit2Var(pCut0->iCutFunc) );
word * pTruth1s = Vec_MemReadEntry( p->vTtMem, Abc_Lit2Var(pCut1->iCutFunc) ); word * pTruth1s = Vec_MemReadEntry( p->vTtMem[pCut1->nLeaves], Abc_Lit2Var(pCut1->iCutFunc) );
word * pTruth0 = (word *)p->puTemp[0]; word * pTruth0 = (word *)p->puTemp[0];
word * pTruth1 = (word *)p->puTemp[1]; word * pTruth1 = (word *)p->puTemp[1];
word * pTruth = (word *)p->puTemp[2]; word * pTruth = (word *)p->puTemp[2];
@ -160,7 +162,8 @@ int If_CutComputeTruthPerm( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_
assert( pCut1->iCutDsd >= 0 ); assert( pCut1->iCutDsd >= 0 );
Abc_TtCopy( pTruth0, pTruth0s, nWords, fCompl0 ^ pCut0->fCompl ^ Abc_LitIsCompl(pCut0->iCutFunc) ); Abc_TtCopy( pTruth0, pTruth0s, nWords, fCompl0 ^ pCut0->fCompl ^ Abc_LitIsCompl(pCut0->iCutFunc) );
Abc_TtCopy( pTruth1, pTruth1s, nWords, fCompl1 ^ pCut1->fCompl ^ Abc_LitIsCompl(pCut1->iCutFunc) ); Abc_TtCopy( pTruth1, pTruth1s, nWords, fCompl1 ^ pCut1->fCompl ^ Abc_LitIsCompl(pCut1->iCutFunc) );
Abc_TtStretch6( pTruth0, pCut0->nLeaves, pCut->nLeaves );
Abc_TtStretch6( pTruth1, pCut1->nLeaves, pCut->nLeaves );
if ( fVerbose ) if ( fVerbose )
{ {
@ -183,7 +186,7 @@ if ( fVerbose )
Place = p->pPerm[1][v]; Place = p->pPerm[1][v];
if ( Place == v || Place == -1 ) if ( Place == v || Place == -1 )
continue; continue;
Abc_TtSwapVars( pTruth1, pCut->nLimit, v, Place ); Abc_TtSwapVars( pTruth1, pCut->nLeaves, v, Place );
p->pPerm[1][v] = p->pPerm[1][Place]; p->pPerm[1][v] = p->pPerm[1][Place];
p->pPerm[1][Place] = Place; p->pPerm[1][Place] = Place;
v--; v--;
@ -200,7 +203,7 @@ if ( fVerbose )
// minimize support // minimize support
if ( p->pPars->fCutMin ) if ( p->pPars->fCutMin )
{ {
nLeavesNew = Abc_TtMinBase( pTruth, pCut->pLeaves, pCut->nLeaves, pCut->nLimit ); nLeavesNew = Abc_TtMinBase( pTruth, pCut->pLeaves, pCut->nLeaves, pCut->nLeaves );
if ( nLeavesNew < If_CutLeaveNum(pCut) ) if ( nLeavesNew < If_CutLeaveNum(pCut) )
{ {
pCut->nLeaves = nLeavesNew; pCut->nLeaves = nLeavesNew;
@ -226,7 +229,7 @@ if ( fVerbose )
// hash function // hash function
fCompl = ((uCanonPhase >> pCut->nLeaves) & 1); fCompl = ((uCanonPhase >> pCut->nLeaves) & 1);
truthId = Vec_MemHashInsert( p->vTtMem, pTruth ); truthId = Vec_MemHashInsert( p->vTtMem[pCut->nLeaves], pTruth );
pCut->iCutFunc = Abc_Var2Lit( truthId, fCompl ); pCut->iCutFunc = Abc_Var2Lit( truthId, fCompl );
if ( fVerbose ) if ( fVerbose )