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

Changes to the lazy man's synthesis code.

This commit is contained in:
Alan Mishchenko 2012-01-14 22:37:25 -08:00
parent ac7e665bf6
commit 868ed19469
3 changed files with 142 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/base/abc/abc.h
View File

@ -777,7 +777,7 @@ extern ABC_DLL int Abc_NtkIvyProve( Abc_Ntk_t ** ppNtk, void * pP
extern ABC_DLL void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts, int fTrim ); extern ABC_DLL void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts, int fTrim );
extern ABC_DLL void Abc_NtkRecStop(); extern ABC_DLL void Abc_NtkRecStop();
extern ABC_DLL void Abc_NtkRecAdd( Abc_Ntk_t * pNtk ); extern ABC_DLL void Abc_NtkRecAdd( Abc_Ntk_t * pNtk );
extern ABC_DLL void Abc_NtkRecPs(); extern ABC_DLL void Abc_NtkRecPs(int fPrintLib);
extern ABC_DLL void Abc_NtkRecFilter(int nLimit); extern ABC_DLL void Abc_NtkRecFilter(int nLimit);
extern ABC_DLL void Abc_NtkRecLibMerge(Abc_Ntk_t * pNtk); extern ABC_DLL void Abc_NtkRecLibMerge(Abc_Ntk_t * pNtk);
extern ABC_DLL Abc_Ntk_t * Abc_NtkRecUse(); extern ABC_DLL Abc_Ntk_t * Abc_NtkRecUse();

9
src/base/abci/abc.c
View File

@ -12125,13 +12125,16 @@ usage:
int Abc_CommandRecPs( Abc_Frame_t * pAbc, int argc, char ** argv ) int Abc_CommandRecPs( Abc_Frame_t * pAbc, int argc, char ** argv )
{ {
Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
int c; int c, fPrintLib = 0;
// set defaults // set defaults
Extra_UtilGetoptReset(); Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "dh" ) ) != EOF ) while ( ( c = Extra_UtilGetopt( argc, argv, "ph" ) ) != EOF )
{ {
switch ( c ) switch ( c )
{ {
case 'p':
fPrintLib ^= 1;
break;
case 'h': case 'h':
goto usage; goto usage;
default: default:
@ -12143,7 +12146,7 @@ int Abc_CommandRecPs( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( -1, "This command works for AIGs only after calling \"rec_start\".\n" ); Abc_Print( -1, "This command works for AIGs only after calling \"rec_start\".\n" );
return 0; return 0;
} }
Abc_NtkRecPs(); Abc_NtkRecPs(fPrintLib);
return 0; return 0;
usage: usage:

179
src/base/abci/abcRec.c
View File

@ -48,7 +48,7 @@ struct Rec_Obj_t_
Rec_Obj_t* pNext; // link to the next structure of the same functional class Rec_Obj_t* pNext; // link to the next structure of the same functional class
Rec_Obj_t* pCopy; // link to the next functional class in the same bucket Rec_Obj_t* pCopy; // link to the next functional class in the same bucket
int Id; // structure's ID int Id; // structure's ID
unsigned nFrequency; // appear times of this functional class among benchmarks int nFrequency; // appear times of this functional class among benchmarks
unsigned char cost; // structure's cost unsigned char cost; // structure's cost
char* pinToPinDelay; // structure's pin-to-pin delay char* pinToPinDelay; // structure's pin-to-pin delay
}; };
@ -112,6 +112,7 @@ struct Abc_ManRec_t_
int timeInsert; // the runtime to insert a structure. int timeInsert; // the runtime to insert a structure.
int timeBuild; // the runtime to build a new structure in the library. int timeBuild; // the runtime to build a new structure in the library.
int timeMerge; // the runtime to merge libraries; int timeMerge; // the runtime to merge libraries;
int timeReHash; // the runtime to resize the hash table.
int timeOther; // the runtime of other int timeOther; // the runtime of other
int timeTotal; // the runtime to total. int timeTotal; // the runtime to total.
}; };
@ -119,7 +120,7 @@ struct Abc_ManRec_t_
// the truth table is canonicized in such a way that for (00000) its value is 0 // the truth table is canonicized in such a way that for (00000) its value is 0
static Rec_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t * p, unsigned * pTruth, int nVars ); static Rec_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t* p, Rec_Obj_t ** pBins, int nBins, unsigned * pTruth, int nVars );
static int Abc_NtkRecComputeTruth( Abc_Obj_t * pObj, Vec_Ptr_t * vTtNodes, int nVars ); static int Abc_NtkRecComputeTruth( Abc_Obj_t * pObj, Vec_Ptr_t * vTtNodes, int nVars );
static int Abc_NtkRecAddCutCheckCycle_rec( Abc_Obj_t * pRoot, Abc_Obj_t * pObj ); static int Abc_NtkRecAddCutCheckCycle_rec( Abc_Obj_t * pRoot, Abc_Obj_t * pObj );
static void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars ); static void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars );
@ -133,7 +134,7 @@ static inline int Abc_ObjGetMax( Abc_Obj_t * pObj ) { return (pObj->
static inline void Abc_NtkRecFrequencyInc(Rec_Obj_t* entry) static inline void Abc_NtkRecFrequencyInc(Rec_Obj_t* entry)
{ {
// the hit number of this functional class increased // the hit number of this functional class increased
if (entry != NULL && entry->nFrequency < 0xffffffff) if (entry != NULL && entry->nFrequency < 0x7fffffff)
entry->nFrequency += 1; entry->nFrequency += 1;
} }
@ -306,19 +307,62 @@ char If_CutDepthRecComput_rec(Abc_Obj_t* pObj, int iLeaf)
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
unsigned char If_CutAreaRecComput_rec(Abc_Obj_t* pObj) unsigned char Abc_NtkRecAreaAndMark_rec(Abc_Obj_t* pObj)
{ {
unsigned char Area0, Area1, Area; unsigned char Area0, Area1, Area;
pObj = Abc_ObjRegular(pObj); pObj = Abc_ObjRegular(pObj);
if(pObj->Type == ABC_OBJ_PI ) if(Abc_ObjIsCi(pObj) || pObj->fMarkA == 1)
return 0; return 0;
Area0 = If_CutAreaRecComput_rec(Abc_ObjFanin0(pObj)); Area0 = Abc_NtkRecAreaAndMark_rec(Abc_ObjFanin0(pObj));
Area1 = If_CutAreaRecComput_rec(Abc_ObjFanin1(pObj)); Area1 = Abc_NtkRecAreaAndMark_rec(Abc_ObjFanin1(pObj));
Area = Area1 + Area0 + 1; Area = Area1 + Area0 + 1;
assert(Area <= 255); assert(Area <= 255);
pObj->fMarkA = 1;
return Area; return Area;
} }
/**Function*************************************************************
Synopsis [Compute area of the structure.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecAreaUnMark_rec(Abc_Obj_t* pObj)
{
pObj = Abc_ObjRegular(pObj);
if ( Abc_ObjIsCi(pObj) || pObj->fMarkA == 0 )
return;
Abc_NtkRecAreaUnMark_rec( Abc_ObjFanin0(pObj) );
Abc_NtkRecAreaUnMark_rec( Abc_ObjFanin1(pObj) );
assert( pObj->fMarkA ); // loop detection
pObj->fMarkA = 0;
}
/**Function*************************************************************
Synopsis [Compute area of the structure.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
unsigned char Abc_NtkRecArea(Abc_Obj_t* pObj)
{
unsigned char area;
area = Abc_NtkRecAreaAndMark_rec(pObj);
Abc_NtkRecAreaUnMark_rec(pObj);
return area;
}
/**Function************************************************************* /**Function*************************************************************
Synopsis [Compare delay profile of two structures.] Synopsis [Compare delay profile of two structures.]
@ -496,7 +540,7 @@ void Abc_NtkRecInsertToLookUpTable(Abc_ManRec_t* p, Rec_Obj_t** ppSpot, Abc_Obj_
int i; int i;
Abc_Obj_t* pLeaf; Abc_Obj_t* pLeaf;
Rec_Obj_t* entry, *previous = NULL, *current = * ppSpot; Rec_Obj_t* entry, *previous = NULL, *current = * ppSpot;
unsigned char costFromStruct = If_CutAreaRecComput_rec(pObj); unsigned char costFromStruct = Abc_NtkRecArea(pObj);
Abc_LookUpStatus_t result; Abc_LookUpStatus_t result;
for (i = 0; i < nVars; i++) for (i = 0; i < nVars; i++)
{ {
@ -668,11 +712,11 @@ Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut )
pCanonPerm[i] = i; pCanonPerm[i] = i;
uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints); uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints);
If_CutTruthStretch(pInOut, nLeaves, nVars); If_CutTruthStretch(pInOut, nLeaves, nVars);
ppSpot = Abc_NtkRecTableLookup( s_pMan, pInOut, nVars ); ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pInOut, nVars );
if (*ppSpot == NULL) if (*ppSpot == NULL)
{ {
Kit_TruthNot(pInOut, pInOut, nVars); Kit_TruthNot(pInOut, pInOut, nVars);
ppSpot = Abc_NtkRecTableLookup( s_pMan, pInOut, nVars ); ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pInOut, nVars );
fCompl = 1; fCompl = 1;
} }
assert(*ppSpot != NULL); assert(*ppSpot != NULL);
@ -834,7 +878,7 @@ void Abc_NtkRecFilter(int nLimit)
{ {
assert(entry->nFrequency != 0); assert(entry->nFrequency != 0);
// only filter the functional classed with frequency less than nLimit. // only filter the functional classed with frequency less than nLimit.
if((int)entry->nFrequency > nLimit) if(entry->nFrequency > nLimit)
{ {
previous = entry; previous = entry;
continue; continue;
@ -983,6 +1027,52 @@ void Abc_NtkRecLibMerge(Abc_Ntk_t* pNtk)
s_pMan->timeTotal += clock() - clk; s_pMan->timeTotal += clock() - clk;
} }
/**Function*************************************************************
Synopsis [Resize the hash table.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecRezieHash(Abc_ManRec_t* p)
{
Rec_Obj_t ** pBinsNew, **ppSpot;
Rec_Obj_t * pEntry, * pTemp;
int nBinsNew, Counter, i;
int clk = clock();
// get the new table size
nBinsNew = Cudd_Prime( 3 * p->nBins );
printf("Hash table resize from %d to %d.\n", p->nBins, nBinsNew);
// allocate a new array
pBinsNew = ABC_ALLOC( Rec_Obj_t *, nBinsNew );
memset( pBinsNew, 0, sizeof(Rec_Obj_t *) * nBinsNew );
// rehash the entries from the old table
Counter = 0;
for ( i = 0; i < p->nBins; i++ )
for ( pEntry = p->pBins[i]; pEntry;)
{
pTemp = pEntry->pCopy;
ppSpot = Abc_NtkRecTableLookup(p, pBinsNew, nBinsNew, (unsigned *)Vec_PtrEntry(p->vTtNodes, pEntry->Id), p->nVars);
assert(*ppSpot == NULL);
*ppSpot = pEntry;
pEntry->pCopy = NULL;
pEntry = pTemp;
Counter++;
}
assert( Counter == p->nAddedFuncs);
ABC_FREE( p->pBins );
p->pBins = pBinsNew;
p->nBins = nBinsNew;
p->timeReHash += clock() - clk;
p->timeTotal += clock() - clk;
}
/**Function************************************************************* /**Function*************************************************************
Synopsis [Starts the record for the given network.] Synopsis [Starts the record for the given network.]
@ -1070,7 +1160,7 @@ void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts, int fTrim )
// create hash table // create hash table
//p->nBins = 50011; //p->nBins = 50011;
p->nBins =500011; p->nBins =97;
p->pBins = ABC_ALLOC( Rec_Obj_t *, p->nBins ); p->pBins = ABC_ALLOC( Rec_Obj_t *, p->nBins );
memset( p->pBins, 0, sizeof(Rec_Obj_t *) * p->nBins ); memset( p->pBins, 0, sizeof(Rec_Obj_t *) * p->nBins );
@ -1108,7 +1198,9 @@ p->timeTruth += clock() - clk;
pObj = Abc_ObjFanin0(pObj); pObj = Abc_ObjFanin0(pObj);
pTruth = (unsigned *)Vec_PtrEntry( p->vTtNodes, pObj->Id ); pTruth = (unsigned *)Vec_PtrEntry( p->vTtNodes, pObj->Id );
// add the resulting truth table to the hash table // add the resulting truth table to the hash table
ppSpot = Abc_NtkRecTableLookup( p, pTruth, p->nVars ); if(p->nAddedFuncs > 2 * p->nBins)
Abc_NtkRecRezieHash(p);
ppSpot = Abc_NtkRecTableLookup(p, p->pBins, p->nBins, pTruth, p->nVars );
Abc_NtkRecInsertToLookUpTable(p, ppSpot, pObj, Abc_ObjGetMax(pObj), p->fTrim); Abc_NtkRecInsertToLookUpTable(p, ppSpot, pObj, Abc_ObjGetMax(pObj), p->fTrim);
} }
p->timeInsert += clock() - timeInsert; p->timeInsert += clock() - timeInsert;
@ -1223,7 +1315,7 @@ Abc_Ntk_t * Abc_NtkRecUse()
Abc_ManRec_t * p = s_pMan; Abc_ManRec_t * p = s_pMan;
Abc_Ntk_t * pNtk = p->pNtk; Abc_Ntk_t * pNtk = p->pNtk;
assert( p != NULL ); assert( p != NULL );
Abc_NtkRecPs(); Abc_NtkRecPs(0);
p->pNtk = NULL; p->pNtk = NULL;
Abc_NtkRecStop(); Abc_NtkRecStop();
Abc_NtkCleanData(pNtk); Abc_NtkCleanData(pNtk);
@ -1242,7 +1334,7 @@ Abc_Ntk_t * Abc_NtkRecUse()
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
void Abc_NtkRecPs() void Abc_NtkRecPs(int fPrintLib)
{ {
int Counter, Counters[17] = {0}; int Counter, Counters[17] = {0};
int CounterS, CountersS[17] = {0}; int CounterS, CountersS[17] = {0};
@ -1251,20 +1343,19 @@ void Abc_NtkRecPs()
Rec_Obj_t * pEntry, * pTemp; Rec_Obj_t * pEntry, * pTemp;
Abc_Obj_t * pObj; Abc_Obj_t * pObj;
int i; int i;
#ifdef LibOut
FILE * pFile; FILE * pFile;
unsigned* pTruth; unsigned* pTruth;
Rec_Obj_t* entry; Rec_Obj_t* entry;
int j; int j;
int nVars = 6; int nVars = s_pMan->nVars;
#endif
// set the max PI number // set the max PI number
Abc_NtkForEachPi( pNtk, pObj, i ) Abc_NtkForEachPi( pNtk, pObj, i )
Abc_ObjSetMax( pObj, i+1 ); Abc_ObjSetMax( pObj, i+1 );
Abc_AigForEachAnd( pNtk, pObj, i ) Abc_AigForEachAnd( pNtk, pObj, i )
Abc_ObjSetMax( pObj, ABC_MAX( Abc_ObjGetMax(Abc_ObjFanin0(pObj)), Abc_ObjGetMax(Abc_ObjFanin1(pObj)) ) ); Abc_ObjSetMax( pObj, ABC_MAX( Abc_ObjGetMax(Abc_ObjFanin0(pObj)), Abc_ObjGetMax(Abc_ObjFanin1(pObj)) ) );
#ifdef LibOut if(fPrintLib)
pFile = fopen( "tt10.txt", "wb" ); {
pFile = fopen( "tt10.txt", "wb" );
for ( i = 0; i < p->nBins; i++ ) for ( i = 0; i < p->nBins; i++ )
for ( entry = p->pBins[i]; entry; entry = entry->pCopy ) for ( entry = p->pBins[i]; entry; entry = entry->pCopy )
{ {
@ -1273,7 +1364,7 @@ for ( i = 0; i < p->nBins; i++ )
/*if ( (int)Kit_TruthSupport(pTruth, nVars) != (1<<nVars)-1 ) /*if ( (int)Kit_TruthSupport(pTruth, nVars) != (1<<nVars)-1 )
continue;*/ continue;*/
Extra_PrintHex( pFile, pTruth, nVars ); Extra_PrintHex( pFile, pTruth, nVars );
fprintf( pFile, " : nVars: %d, Frequency:%d : ", Abc_ObjGetMax(entry->obj), entry->nFrequency); fprintf( pFile, " : nVars: %d, Frequency:%d, nBin:%d : ", Abc_ObjGetMax(entry->obj), entry->nFrequency, i);
Kit_DsdPrintFromTruth2( pFile, pTruth, Abc_ObjGetMax(entry->obj) ); Kit_DsdPrintFromTruth2( pFile, pTruth, Abc_ObjGetMax(entry->obj) );
fprintf( pFile, "\n" ); fprintf( pFile, "\n" );
for ( pTemp = entry; pTemp; pTemp = pTemp->pNext ) for ( pTemp = entry; pTemp; pTemp = pTemp->pNext )
@ -1283,14 +1374,15 @@ for ( i = 0; i < p->nBins; i++ )
{ {
fprintf(pFile, " %d, ", pTemp->pinToPinDelay[j]); fprintf(pFile, " %d, ", pTemp->pinToPinDelay[j]);
} }
fprintf(pFile, "cost = %d\n", pTemp->cost); fprintf(pFile, "cost = %d ID = %d\n", pTemp->cost, pTemp->Id);
tmp++; tmp++;
} }
fprintf( pFile, "\n"); fprintf( pFile, "\n");
fprintf( pFile, "\n"); fprintf( pFile, "\n");
} }
fclose( pFile) ; fclose( pFile) ;
#endif }
// go through the table // go through the table
Counter = CounterS = 0; Counter = CounterS = 0;
for ( i = 0; i < p->nBins; i++ ) for ( i = 0; i < p->nBins; i++ )
@ -1334,11 +1426,12 @@ for ( i = 0; i < p->nBins; i++ )
printf( "Functions added = %10d. (%6.2f %%)\n", p->nAddedFuncs, !p->nTried? 0 : 100.0*p->nAddedFuncs/p->nTried ); printf( "Functions added = %10d. (%6.2f %%)\n", p->nAddedFuncs, !p->nTried? 0 : 100.0*p->nAddedFuncs/p->nTried );
if(s_pMan->fTrim) if(s_pMan->fTrim)
printf( "Functions trimed = %10d. (%6.2f %%)\n", p->nTrimed, !p->nTried? 0 : 100.0*p->nTrimed/p->nTried ); printf( "Functions trimed = %10d. (%6.2f %%)\n", p->nTrimed, !p->nTried? 0 : 100.0*p->nTrimed/p->nTried );
p->timeOther = p->timeTotal - p->timeCollect - p->timeTruth - p->timeCanon - p->timeInsert - p->timeBuild - p->timeTrim - p->timeMerge; p->timeOther = p->timeTotal - p->timeCollect - p->timeTruth - p->timeCanon - p->timeInsert - p->timeBuild - p->timeTrim - p->timeMerge - p->timeReHash;
ABC_PRTP( "Collecting nodes ", p->timeCollect, p->timeTotal); ABC_PRTP( "Collecting nodes ", p->timeCollect, p->timeTotal);
ABC_PRTP( "Computing truth ", p->timeTruth, p->timeTotal ); ABC_PRTP( "Computing truth ", p->timeTruth, p->timeTotal );
ABC_PRTP( "Canonicizing ", p->timeCanon, p->timeTotal ); ABC_PRTP( "Canonicizing ", p->timeCanon, p->timeTotal );
ABC_PRTP( "Building ", p->timeBuild, p->timeTotal ); ABC_PRTP( "Building ", p->timeBuild, p->timeTotal );
ABC_PRTP( "ReHash ", p->timeReHash, p->timeTotal );
ABC_PRTP( "Merge ", p->timeMerge, p->timeTotal ); ABC_PRTP( "Merge ", p->timeMerge, p->timeTotal );
ABC_PRTP( "Insert ", p->timeInsert, p->timeTotal); ABC_PRTP( "Insert ", p->timeInsert, p->timeTotal);
if(s_pMan->fTrim) if(s_pMan->fTrim)
@ -1397,11 +1490,11 @@ static inline unsigned Abc_NtkRecTableHash( unsigned * pTruth, int nVars, int nB
SeeAlso [] SeeAlso []
***********************************************************************/ ***********************************************************************/
Rec_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t * p, unsigned * pTruth, int nVars ) Rec_Obj_t ** Abc_NtkRecTableLookup(Abc_ManRec_t* p, Rec_Obj_t ** pBins, int nBins, unsigned * pTruth, int nVars )
{ {
static int s_Primes[10] = { 1291, 1699, 2357, 4177, 5147, 5647, 6343, 7103, 7873, 8147 }; static int s_Primes[10] = { 1291, 1699, 2357, 4177, 5147, 5647, 6343, 7103, 7873, 8147 };
Rec_Obj_t ** ppSpot, * pEntry; Rec_Obj_t ** ppSpot, * pEntry;
ppSpot = p->pBins + Abc_NtkRecTableHash( pTruth, nVars, p->nBins, s_Primes ); ppSpot = pBins + Abc_NtkRecTableHash( pTruth, nVars, nBins, s_Primes );
for ( pEntry = *ppSpot; pEntry; ppSpot = &pEntry->pCopy, pEntry = pEntry->pCopy ) for ( pEntry = *ppSpot; pEntry; ppSpot = &pEntry->pCopy, pEntry = pEntry->pCopy )
if ( Kit_TruthIsEqualWithPhase((unsigned *)Vec_PtrEntry(p->vTtNodes, pEntry->Id), pTruth, nVars) ) if ( Kit_TruthIsEqualWithPhase((unsigned *)Vec_PtrEntry(p->vTtNodes, pEntry->Id), pTruth, nVars) )
return ppSpot; return ppSpot;
@ -1472,8 +1565,9 @@ void Abc_NtkRecAdd( Abc_Ntk_t * pNtk )
pPars->fLatchPaths = 0; pPars->fLatchPaths = 0;
pPars->fSeqMap = 0; pPars->fSeqMap = 0;
pPars->fVerbose = 0; pPars->fVerbose = 0;
//pPars->fCutMin = 1;
// internal parameters // internal parameters
pPars->fTruth = 0; pPars->fTruth = 1;
pPars->fUsePerm = 0; pPars->fUsePerm = 0;
pPars->nLatches = 0; pPars->nLatches = 0;
pPars->pLutLib = NULL; // Abc_FrameReadLibLut(); pPars->pLutLib = NULL; // Abc_FrameReadLibLut();
@ -1935,16 +2029,18 @@ clk = clock();
return 1; return 1;
} }
// Extra_PrintBinary( stdout, pInOut, 8 ); printf( "\n" ); // Extra_PrintBinary( stdout, pInOut, 8 ); printf( "\n" );
// look up in the hash table and increase the hit number of the functional class // look up in the hash table and increase the hit number of the functional class
ppSpot = Abc_NtkRecTableLookup( s_pMan, pTruth, nInputs ); if(s_pMan->nAddedFuncs > 2 * s_pMan->nBins)
Abc_NtkRecFrequencyInc(*ppSpot); Abc_NtkRecRezieHash(s_pMan);
ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins,s_pMan->nBins , pTruth, nInputs );
Abc_NtkRecFrequencyInc(*ppSpot);
// if not new nodes were added and the node has a CO fanout // if not new nodes were added and the node has a CO fanout
if ( nNodesBeg == Abc_NtkObjNumMax(pAig) && Abc_NodeFindCoFanout(pObj) != NULL ) if ( nNodesBeg == Abc_NtkObjNumMax(pAig) && Abc_NodeFindCoFanout(pObj) != NULL )
{ {
s_pMan->nFilterSame++; s_pMan->nFilterSame++;
assert(*ppSpot != NULL); //assert(*ppSpot != NULL);
return 1; return 1;
} }
@ -1995,18 +2091,12 @@ void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars )
unsigned * pTemp = s_pMan->pTemp2; unsigned * pTemp = s_pMan->pTemp2;
unsigned * pTruth; unsigned * pTruth;
int i, RetValue, nNodes, nNodesBeg, nInputs = s_pMan->nVars, nLeaves = nVars; int i, RetValue, nNodes, nNodesBeg, nInputs = s_pMan->nVars, nLeaves = nVars;
assert( nInputs <= 16 ); assert( nInputs <= 16 );
// collect internal nodes and skip redundant cuts // collect internal nodes and skip redundant cuts
Abc_NtkRecCollectNodesFromLib(pNtk, pRoot, vNodes , nLeaves); Abc_NtkRecCollectNodesFromLib(pNtk, pRoot, vNodes , nLeaves);
Abc_NtkRecCutTruthFromLib(vNodes, nLeaves, s_pMan->vTtTemps, s_pMan->vTtElems ); Abc_NtkRecCutTruthFromLib(vNodes, nLeaves, s_pMan->vTtTemps, s_pMan->vTtElems );
// copy the truth table // copy the truth table
Kit_TruthCopy( pInOut, (unsigned *)pRoot->pTemp, nInputs ); Kit_TruthCopy( pInOut, (unsigned *)pRoot->pTemp, nInputs );
// go through the variables in the new truth table // go through the variables in the new truth table
for ( i = 0; i < nLeaves; i++ ) for ( i = 0; i < nLeaves; i++ )
{ {
@ -2038,7 +2128,6 @@ void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars )
while ( Vec_PtrSize(s_pMan->vTtNodes) <= pObj->Id ) while ( Vec_PtrSize(s_pMan->vTtNodes) <= pObj->Id )
// Vec_PtrPush( s_pMan->vTtNodes, ABC_ALLOC(unsigned, s_pMan->nWords) ); // Vec_PtrPush( s_pMan->vTtNodes, ABC_ALLOC(unsigned, s_pMan->nWords) );
Vec_PtrPush( s_pMan->vTtNodes, Mem_FixedEntryFetch(s_pMan->pMmTruth) ); Vec_PtrPush( s_pMan->vTtNodes, Mem_FixedEntryFetch(s_pMan->pMmTruth) );
// compute the truth table // compute the truth table
RetValue = Abc_NtkRecComputeTruth( pObj, s_pMan->vTtNodes, nInputs ); RetValue = Abc_NtkRecComputeTruth( pObj, s_pMan->vTtNodes, nInputs );
if ( RetValue == 0 ) if ( RetValue == 0 )
@ -2057,13 +2146,15 @@ void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars )
// Extra_PrintBinary( stdout, pInOut, 8 ); printf( "\n" ); // Extra_PrintBinary( stdout, pInOut, 8 ); printf( "\n" );
// look up in the hash table and increase the hit number of the functional class // look up in the hash table and increase the hit number of the functional class
ppSpot = Abc_NtkRecTableLookup( s_pMan, pTruth, nInputs ); if(s_pMan->nAddedFuncs > 2 * s_pMan->nBins)
Abc_NtkRecRezieHash(s_pMan);
ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pTruth, nInputs );
// if not new nodes were added and the node has a CO fanout // if not new nodes were added and the node has a CO fanout
if ( nNodesBeg == Abc_NtkObjNumMax(pAig) && Abc_NodeFindCoFanout(pObj) != NULL ) if ( nNodesBeg == Abc_NtkObjNumMax(pAig) && Abc_NodeFindCoFanout(pObj) != NULL )
{ {
s_pMan->nFilterSame++; s_pMan->nFilterSame++;
assert(*ppSpot != NULL); //assert(*ppSpot != NULL);
return; return;
} }
@ -2132,11 +2223,11 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut)
uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints); uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints);
If_CutTruthStretch(pInOut, nLeaves, nVars); If_CutTruthStretch(pInOut, nLeaves, nVars);
s_pMan->timeIfCanonicize += clock() - timeCanonicize; s_pMan->timeIfCanonicize += clock() - timeCanonicize;
ppSpot = Abc_NtkRecTableLookup( s_pMan, pInOut, nVars ); ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pInOut, nVars );
if (*ppSpot == NULL) if (*ppSpot == NULL)
{ {
Kit_TruthNot(pInOut, pInOut, nVars); Kit_TruthNot(pInOut, pInOut, nVars);
ppSpot = Abc_NtkRecTableLookup( s_pMan, pInOut, nVars ); ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pInOut, nVars );
} }
assert (!(*ppSpot == NULL && nLeaves == 2)); assert (!(*ppSpot == NULL && nLeaves == 2));
//functional class not found in the library. //functional class not found in the library.