Skip to content

A
abc
Commit 6c19c1df by Alan Mishchenko
Options

Delay optimization using precomputed library.

parent fce98abf
Showing with 1011 additions and 125 deletions
src/base/abc/abc.h
......@@ -772,13 +772,14 @@ extern ABC_DLL void Abc_NtkShow6VarFunc( char * pF0, char * pF1 );
extern ABC_DLL int Abc_NtkMiterProve( Abc_Ntk_t ** ppNtk, void * pParams );
extern ABC_DLL int Abc_NtkIvyProve( Abc_Ntk_t ** ppNtk, void * pPars );
/*=== abcRec.c ==========================================================*/
extern ABC_DLL void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts );
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_NtkRecAdd( Abc_Ntk_t * pNtk );
extern ABC_DLL void Abc_NtkRecPs();
extern ABC_DLL void Abc_NtkRecFilter( int iVar, int iPlus );
extern ABC_DLL void Abc_NtkRecFilter(int nLimit);
extern ABC_DLL Abc_Ntk_t * Abc_NtkRecUse();
extern ABC_DLL int Abc_NtkRecIsRunning();
extern ABC_DLL int Abc_NtkRecIsInTrimMode();
extern ABC_DLL int Abc_NtkRecVarNum();
extern ABC_DLL Vec_Int_t * Abc_NtkRecMemory();
extern ABC_DLL int Abc_NtkRecStrashNode( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, unsigned * pTruth, int nVars );
......
src/base/abci/abc.c
......@@ -211,6 +211,7 @@ static int Abc_CommandRecStop ( Abc_Frame_t * pAbc, int argc, cha
static int Abc_CommandRecAdd ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandRecPs ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandRecUse ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandRecFilter ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandMap ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAmap ( Abc_Frame_t * pAbc, int argc, char ** argv );
......@@ -668,6 +669,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
Cmd_CommandAdd( pAbc, "Choicing", "rec_add", Abc_CommandRecAdd, 0 );
Cmd_CommandAdd( pAbc, "Choicing", "rec_ps", Abc_CommandRecPs, 0 );
Cmd_CommandAdd( pAbc, "Choicing", "rec_use", Abc_CommandRecUse, 1 );
Cmd_CommandAdd( pAbc, "Choicing", "rec_filter", Abc_CommandRecFilter, 1 );
Cmd_CommandAdd( pAbc, "SC mapping", "map", Abc_CommandMap, 1 );
Cmd_CommandAdd( pAbc, "SC mapping", "amap", Abc_CommandAmap, 1 );
......@@ -11935,13 +11937,15 @@ int Abc_CommandRecStart( Abc_Frame_t * pAbc, int argc, char ** argv )
int c;
int nVars;
int nCuts;
int fTrim;
pNtk = Abc_FrameReadNtk(pAbc);
// set defaults
nVars = 6;
nCuts = 8;
fTrim = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "KCh" ) ) != EOF )
while ( ( c = Extra_UtilGetopt( argc, argv, "KCth" ) ) != EOF )
{
switch ( c )
{
......@@ -11967,6 +11971,9 @@ int Abc_CommandRecStart( Abc_Frame_t * pAbc, int argc, char ** argv )
if ( nCuts < 1 )
goto usage;
break;
case 't':
fTrim ^= 1;
break;
case 'h':
goto usage;
default:
......@@ -11988,15 +11995,16 @@ int Abc_CommandRecStart( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( -1, "This command works only for AIGs; run strashing (\"st\").\n" );
return 0;
}
Abc_NtkRecStart( pNtk, nVars, nCuts );
Abc_NtkRecStart( pNtk, nVars, nCuts, fTrim );
return 0;
usage:
Abc_Print( -2, "usage: rec_start [-K num] [-C num] [-h]\n" );
Abc_Print( -2, "usage: rec_start [-K num] [-C num] [-th]\n" );
Abc_Print( -2, "\t starts recording AIG subgraphs (should be called for\n" );
Abc_Print( -2, "\t an empty network or after reading in a previous record)\n" );
Abc_Print( -2, "\t-K num : the largest number of inputs [default = %d]\n", nVars );
Abc_Print( -2, "\t-C num : the max number of cuts used at a node (0 < num < 2^12) [default = %d]\n", nCuts );
Abc_Print( -2, "\t-t : toggles the use of trimming [default = %s]\n", fTrim? "yes": "no" );
Abc_Print( -2, "\t-h : print the command usage\n");
return 1;
}
......@@ -12195,6 +12203,64 @@ usage:
SeeAlso []
***********************************************************************/
int Abc_CommandRecFilter( Abc_Frame_t * pAbc, int argc, char ** argv )
{
Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
int c, nLimit = 0;
// set defaults
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "Fh" ) ) != EOF )
{
switch ( c )
{
case 'F':
if ( globalUtilOptind >= argc )
{
Abc_Print( -1, "Command line switch \"-F\" should be followed by an integer.\n" );
goto usage;
}
nLimit = atoi(argv[globalUtilOptind]);
globalUtilOptind++;
if ( nLimit < 0 )
goto usage;
break;
case 'h':
goto usage;
default:
goto usage;
}
}
if ( !Abc_NtkRecIsRunning() )
{
Abc_Print( -1, "This command works for AIGs only after calling \"rec_start\".\n" );
return 0;
}
if (!Abc_NtkRecIsInTrimMode())
Abc_Print( 0, "This command works fine only in trim mode. Please call \"rec_start -t\" first.\n" );
Abc_NtkRecFilter(nLimit);
return 0;
usage:
Abc_Print( -2, "usage: rec_filter [-h]\n" );
Abc_Print( -2, "\t filter the library of the recorder\n" );
Abc_Print( -2, "\t-F num : the limit number of function class [default = %d]\n", nLimit );
Abc_Print( -2, "\t-h : print the command usage\n");
return 1;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Abc_CommandMap( Abc_Frame_t * pAbc, int argc, char ** argv )
{
Abc_Ntk_t * pNtk, * pNtkRes;
......@@ -13090,7 +13156,7 @@ int Abc_CommandIf( Abc_Frame_t * pAbc, int argc, char ** argv )
fLutMux = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "KCFADEWSqaflepmrsdbugojikcvh" ) ) != EOF )
while ( ( c = Extra_UtilGetopt( argc, argv, "KCFADEWSqaflepmrsdbugyojikcvh" ) ) != EOF )
{
switch ( c )
{
......@@ -13226,6 +13292,9 @@ int Abc_CommandIf( Abc_Frame_t * pAbc, int argc, char ** argv )
case 'g':
pPars->fDelayOpt ^= 1;
break;
case 'y':
pPars->fUserRecLib ^= 1;
break;
case 'o':
pPars->fUseBuffs ^= 1;
break;
......@@ -13375,7 +13444,7 @@ int Abc_CommandIf( Abc_Frame_t * pAbc, int argc, char ** argv )
}
// modify for global delay optimization
if ( pPars->fDelayOpt )
if ( pPars->fDelayOpt || pPars->fUserRecLib )
{
pPars->fTruth = 1;
pPars->fExpRed = 0;
......@@ -13459,7 +13528,7 @@ usage:
sprintf( LutSize, "library" );
else
sprintf( LutSize, "%d", pPars->nLutSize );
Abc_Print( -2, "usage: if [-KCFA num] [-DEW float] [-S str] [-qarlepmsdbugojikcvh]\n" );
Abc_Print( -2, "usage: if [-KCFA num] [-DEW float] [-S str] [-qarlepmsdbugyojikcvh]\n" );
Abc_Print( -2, "\t performs FPGA technology mapping of the network\n" );
Abc_Print( -2, "\t-K num : the number of LUT inputs (2 < num < %d) [default = %s]\n", IF_MAX_LUTSIZE+1, LutSize );
Abc_Print( -2, "\t-C num : the max number of priority cuts (0 < num < 2^12) [default = %d]\n", pPars->nCutsMax );
......@@ -13482,6 +13551,7 @@ usage:
Abc_Print( -2, "\t-b : toggles the use of one special feature [default = %s]\n", pPars->fUseBat? "yes": "no" );
Abc_Print( -2, "\t-u : toggles the use of MUXes along with LUTs [default = %s]\n", fLutMux? "yes": "no" );
Abc_Print( -2, "\t-g : toggles global delay optimization [default = %s]\n", pPars->fDelayOpt? "yes": "no" );
Abc_Print( -2, "\t-y : toggles delay optimization with recorded library [default = %s]\n", pPars->fUserRecLib? "yes": "no" );
Abc_Print( -2, "\t-o : toggles using buffers to decouple combinational outputs [default = %s]\n", pPars->fUseBuffs? "yes": "no" );
Abc_Print( -2, "\t-j : toggles enabling additional check [default = %s]\n", pPars->fEnableCheck07? "yes": "no" );
Abc_Print( -2, "\t-i : toggles enabling additional check [default = %s]\n", pPars->fEnableCheck08? "yes": "no" );
......
src/base/abci/abcIf.c
......@@ -83,7 +83,7 @@ void Abc_NtkIfComputeSwitching( Abc_Ntk_t * pNtk, If_Man_t * pIfMan )
if ( (pObjAig = (Aig_Obj_t *)pObjAbc->pTemp) )
{
pObjAbc->dTemp = pSwitching[pObjAig->Id];
// J. Anderson and F. N. Najm, Power-Aware Technology Mapping for LUT-Based FPGAs,
// J. Anderson and F. N. Najm, Power-Aware Technology Mapping for LUT-Based FPGAs,
// IEEE Intl. Conf. on Field-Programmable Technology, 2002.
// pObjAbc->dTemp = (1.55 + 1.05 / (float) Abc_ObjFanoutNum(pObjAbc)) * pSwitching[pObjAig->Id];
}
......@@ -436,7 +436,7 @@ Abc_Obj_t * Abc_NodeFromIf_rec( Abc_Ntk_t * pNtkNew, If_Man_t * pIfMan, If_Obj_t
pCutBest = If_ObjCutBest( pIfObj );
// printf( "%d 0x%02X %d\n", pCutBest->nLeaves, 0xff & *If_CutTruth(pCutBest), pIfMan->pPars->pFuncCost(pCutBest) );
// if ( pIfMan->pPars->pLutLib && pIfMan->pPars->pLutLib->fVarPinDelays )
if ( !pIfMan->pPars->fDelayOpt && !pIfMan->pPars->pLutStruct )
if ( !pIfMan->pPars->fDelayOpt && !pIfMan->pPars->pLutStruct && !pIfMan->pPars->fUserRecLib )
If_CutRotatePins( pIfMan, pCutBest );
if ( pIfMan->pPars->fUseCnfs || pIfMan->pPars->fUseMv )
{
......@@ -488,6 +488,11 @@ Abc_Obj_t * Abc_NodeFromIf_rec( Abc_Ntk_t * pNtkNew, If_Man_t * pIfMan, If_Obj_t
extern Hop_Obj_t * Abc_NodeTruthToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut );
pNodeNew->pData = Abc_NodeTruthToHop( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest );
}
else if ( pIfMan->pPars->fUserRecLib )
{
extern Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut );
pNodeNew->pData = Abc_RecToHop( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest );
}
else
{
extern Hop_Obj_t * Kit_TruthToHop( Hop_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory );
......
src/base/abci/abcRec.c
......@@ -29,18 +29,44 @@ ABC_NAMESPACE_IMPL_START
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
#define IF_BIG_CHAR 120
typedef struct Abc_ManRec_t_ Abc_ManRec_t;
typedef struct Rec_Obj_t_ Rec_Obj_t;
typedef enum {
REC_ERROR, //0: error
REC_SMALL, //1: smaller than
REC_EQUAL, //2: equal with
REC_BIG, //3: bigger than
REC_DOMINANCE, //4: dominance
REC_BEDOMINANCED //5: be dominated
} Abc_LookUpStatus_t;
struct Rec_Obj_t_
{
Abc_Obj_t* obj; // the actual structure in the library
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
int Id; // structure's ID
unsigned char cost; // structure's cost
char* pinToPinDelay; // structure's pin-to-pin delay
};
struct Abc_ManRec_t_
{
Abc_Ntk_t * pNtk; // the record
Vec_Ptr_t * vTtElems; // the elementary truth tables
Vec_Ptr_t * vTtNodes; // the node truth tables
Abc_Obj_t ** pBins; // hash table mapping truth tables into nodes
Rec_Obj_t ** pBins; // hash table mapping truth tables into nodes
int nBins; // the number of allocated bins
int nVars; // the number of variables
int nVarsInit; // the number of variables requested initially
int nWords; // the number of TT words
int nCuts; // the max number of cuts to use
Mem_Fixed_t * pMemObj; // memory manager for Rec objects
int recObjSize; // size for one Rec object
int fTrim; // filter the library or not.
// temporaries
int * pBytes; // temporary storage for minterms
int * pMints; // temporary storage for minterm counters
......@@ -61,32 +87,695 @@ struct Abc_ManRec_t_
int nFilterSame; // the number of same structures
int nAdded; // the number of subgraphs added
int nAddedFuncs; // the number of functions added
int nIfMapTried;
int nIfMapError;
int nTrimed; // the number of structures filtered
// rewriting
int nFunsFound; // the found functions
int nFunsNotFound; // the missing functions
// runtime
int timeCollect; // the runtime to canonicize
int timeTruth; // the runtime to canonicize
int nFunsTried;
int nFunsFilteredBysupport; // the function filtered when rewriting because not all supports are in use.
int nFunsDelayComput; // the times delay computed, just for statistics
// rewriting runtime
int timeIfTotal; // time used on the whole process of rewriting a structure.
int timeIfComputDelay; // time used on the structure's delay computation.
int timeIfCanonicize; // time used on canonicize the function
int timeIfDerive; // time used on derive the final network;
int timeIfOther; // time used on other things
// record runtime
int timeTrim; // the runtime to filter the library
int timeCollect; // the runtime to collect the node of a structure.
int timeTruth; // the runtime to compute truth table.
int timeCanon; // the runtime to canonicize
int timeOther; // the runtime to canonicize
int timeTotal; // the runtime to canonicize
int timeInsert; // the runtime to insert a structure.
int timeBuild; // the runtime to build a new structure in the library.
int timeOther; // the runtime of other
int timeTotal; // the runtime to total.
};
// the truth table is canonicized in such a way that for (00000) its value is 0
static Abc_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t * p, unsigned * pTruth, int nVars );
static Rec_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t * p, unsigned * pTruth, 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 Abc_ManRec_t * s_pMan = NULL;
static inline void Abc_ObjSetMax( Abc_Obj_t * pObj, int Value ) { assert( pObj->Level < 0xff ); pObj->Level = (Value << 8) | (pObj->Level & 0xff); }
static inline void Abc_ObjClearMax( Abc_Obj_t * pObj ) { pObj->Level = (pObj->Level & 0xff); }
static inline int Abc_ObjGetMax( Abc_Obj_t * pObj ) { return (pObj->Level >> 8) & 0xff; }
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Starts the record for the given network.]
Synopsis [stretch the truthtable to have more input variables.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void If_CutTruthStretch(unsigned* pInOut, int nVarS, int nVarB)
{
int w, i;
int step = Kit_TruthWordNum(nVarS);
int nWords = Kit_TruthWordNum(nVarB);
assert(step <= nWords);
if (step == nWords)
return;
for (w = 0; w <nWords; w += step)
for (i = 0; i < step; i++)
pInOut[w + i] = pInOut[i];
}
/**Function*************************************************************
Synopsis [Alloc the Rec object from its manger.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Rec_Obj_t* Rec_ObjAlloc(Abc_ManRec_t* p, Abc_Obj_t* pObj, char* pinToPinDelay, char cost, int nVar)
{
int i;
Rec_Obj_t * pRecObj;
pRecObj = (Rec_Obj_t *)Mem_FixedEntryFetch( p->pMemObj);
pRecObj->pinToPinDelay = (char*)(pRecObj + 1);
pRecObj->pNext = NULL;
pRecObj->pCopy = NULL;
pRecObj->obj = pObj;
pRecObj->Id = pObj->Id;
for (i = 0; i < nVar; i++)
pRecObj->pinToPinDelay[i] = pinToPinDelay[i];
pRecObj->cost = cost;
return pRecObj;
}
/**Function*************************************************************
Synopsis [set the property of a Rec object.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Rec_ObjSet(Abc_ManRec_t* p, Rec_Obj_t* pRecObj, Abc_Obj_t* pObj, char* newDelay, unsigned char cost, int nVar)
{
int i;
pRecObj->obj = pObj;
pRecObj->Id = pObj->Id;
pRecObj->cost = cost;
for (i = 0; i < nVar; i++)
pRecObj->pinToPinDelay[i] = newDelay[i];
}
/**Function*************************************************************
Synopsis [Compute the delay of the structure recursively.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
/* int If_CutDelayRecComput_rec(Abc_Obj_t* pObj, Vec_Str_t* vCosts)
{
char Delay0, Delay1, Delay;
Abc_Obj_t *pFanin0, *pFanin1;
pObj = Abc_ObjRegular(pObj);
if (Abc_NodeIsTravIdCurrent(pObj) || pObj->Type == ABC_OBJ_PI)
return Vec_StrEntry(vCosts,pObj->Id);
Abc_NodeSetTravIdCurrent(pObj);
Delay0 = If_CutDelayRecComput_rec(Abc_ObjFanin0(pObj), vCosts);
Delay1 = If_CutDelayRecComput_rec(Abc_ObjFanin1(pObj), vCosts);
Delay = ABC_MAX(Delay0, Delay1) + 1;
Vec_StrWriteEntry(vCosts,pObj->Id,Delay);
return Delay;
}*/
/**Function*************************************************************
Synopsis [Compute delay of the structure using pin-to-pin delay.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int If_CutComputDelay(If_Man_t* p, Rec_Obj_t* entry, If_Cut_t* pCut, char* pCanonPerm , int nVars)
{
If_Obj_t* pLeaf;
int i, delayTemp, delayMax = -ABC_INFINITY;
for (i = 0; i < nVars; i++)
{
pLeaf = If_ManObj(p, (pCut)->pLeaves[pCanonPerm[i]]);
pLeaf = If_Regular(pLeaf);
delayTemp = entry->pinToPinDelay[i] + If_ObjCutBest(pLeaf)->Delay;
if(delayTemp > delayMax)
delayMax = delayTemp;
}
// plus each pin's delay with its pin-to-output delay, the biggest one is the delay of the structure.
return delayMax;
}
/**Function*************************************************************
Synopsis [Compute pin-to-pin delay of the structure.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char If_CutDepthRecComput_rec(Abc_Obj_t* pObj, int iLeaf)
{
char Depth0, Depth1, Depth;
pObj = Abc_ObjRegular(pObj);
if(pObj->Id == iLeaf)
return 0;
if(pObj->Type == ABC_OBJ_PI )
return -IF_BIG_CHAR;
Depth0 = If_CutDepthRecComput_rec(Abc_ObjFanin0(pObj), iLeaf);
Depth1 = If_CutDepthRecComput_rec(Abc_ObjFanin1(pObj), iLeaf);
Depth = ABC_MAX(Depth0, Depth1);
Depth = (Depth == -IF_BIG_CHAR) ? -IF_BIG_CHAR : Depth + 1;
assert(Depth <= 127);
return Depth;
}
/**Function*************************************************************
Synopsis [Compute area of the structure.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
unsigned char If_CutAreaRecComput_rec(Abc_Obj_t* pObj)
{
unsigned char Area0, Area1, Area;
pObj = Abc_ObjRegular(pObj);
if(pObj->Type == ABC_OBJ_PI )
return 0;
Area0 = If_CutAreaRecComput_rec(Abc_ObjFanin0(pObj));
Area1 = If_CutAreaRecComput_rec(Abc_ObjFanin1(pObj));
Area = Area1 + Area0 + 1;
assert(Area <= 255);
return Area;
}
/**Function*************************************************************
Synopsis [Compare delay profile of two structures.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_LookUpStatus_t ABC_NtkRecDelayCompare(char* delayFromStruct, char* delayFromTable, int nVar)
{
int i, bigThan = 0, smallThan = 0, equal = 1, dominace = 1, beDominaced = 1;
for (i = 0; i < nVar; i++)
{
if(delayFromStruct[i] < delayFromTable[i])
{
equal = 0;
beDominaced = 0;
if(bigThan == 0)
smallThan = 1;
}
else if (delayFromStruct[i] > delayFromTable[i])
{
equal = 0;
dominace = 0;
if (smallThan == 0)
bigThan = 1;
}
}
if(equal)
return REC_EQUAL;
else if(dominace)
return REC_DOMINANCE;
else if(beDominaced)
return REC_BEDOMINANCED;
if(bigThan)
return REC_BIG;
else if(smallThan)
return REC_SMALL;
else
return REC_SMALL;
}
/**Function*************************************************************
Synopsis [link a useless PO to constant 0.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecReplacePO(Abc_Obj_t* pObj )
{
Abc_Obj_t * pConst0, * pFaninNew;
Abc_Ntk_t * pNtk = pObj->pNtk;
if ( Abc_ObjFanin0(pObj) == Abc_AigConst1(pNtk) )
{
if ( !Abc_ObjFaninC0(pObj) )
Abc_ObjXorFaninC( pObj, 0 );
return;
}
pConst0 = Abc_ObjNot( Abc_AigConst1(pNtk) );
pFaninNew = Abc_ObjNotCond( pConst0, Abc_ObjFaninC0(pObj) );
Abc_ObjPatchFanin( pObj, Abc_ObjFanin0(pObj), pFaninNew );
assert( Abc_ObjChild0(pObj) == pConst0 );
//Abc_AigCleanup( (Abc_Aig_t *)pNtk->pManFunc );
}
/**Function*************************************************************
Synopsis [Delete a useless structure in the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecDeleteSubGragh(Abc_ManRec_t* p, Abc_Obj_t* pObj)
{
Abc_Obj_t* pFanOut;
int i, deleted = 0;
Abc_ObjForEachFanout(pObj, pFanOut, i)
{
if (Abc_ObjIsCo(pFanOut))
{
Abc_NtkRecReplacePO(pFanOut);
deleted++;
p->nTrimed++;
}
}
assert(deleted == 1);
}
/**Function*************************************************************
Synopsis [Check if the structure is dominant or not.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int ABC_NtkRecIsDominant(char* delayFromStruct, char* delayFromTable, int nVar)
{
int i;
for (i = 0; i < nVar; i++)
{
if(delayFromStruct[i] > delayFromTable[i])
return 0;
}
return 1;
}
/**Function*************************************************************
Synopsis [Sweep the dominated structures.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecSweepDominance(Abc_ManRec_t* p, Rec_Obj_t* previous, Rec_Obj_t* current, char * delayFromStruct, int nVars, int fTrim)
{
Abc_Obj_t* pObj;
while(current != NULL)
{
if (ABC_NtkRecIsDominant(delayFromStruct, current->pinToPinDelay, nVars))
{
pObj = current->obj;
previous->pNext = current->pNext;
current->pNext = NULL;
Mem_FixedEntryRecycle(p->pMemObj, (char *)current);
current = previous->pNext;
p->nAdded--;
// if filter the library is needed, then point the PO to a constant.
if (fTrim)
Abc_NtkRecDeleteSubGragh(p, pObj);
}
else
{
previous = current;
current = current->pNext;
}
}
}
/**Function*************************************************************
Synopsis [Insert a structure into the look up table.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecInsertToLookUpTable(Abc_ManRec_t* p, Rec_Obj_t** ppSpot, Abc_Obj_t* pObj, int nVars, int fTrim)
{
char delayFromStruct[16] ;
int i;
Abc_Obj_t* pLeaf;
Rec_Obj_t* entry, *previous = NULL, *current = * ppSpot;
unsigned char costFromStruct = If_CutAreaRecComput_rec(pObj);
Abc_LookUpStatus_t result;
for (i = 0; i < nVars; i++)
{
pLeaf = Abc_NtkPi( p->pNtk, i);
pLeaf =Abc_ObjRegular(pLeaf);
delayFromStruct[i] = If_CutDepthRecComput_rec(pObj, pLeaf->Id);
}
while(1)
{
if (current == NULL)
{
p->nAdded++;
entry = Rec_ObjAlloc(p, pObj, delayFromStruct, costFromStruct, nVars);
if(previous != NULL)
{
previous->pNext = entry;
}
else
{
// new functional class found
p->nAddedFuncs++;
*ppSpot = entry;
}
break;
}
result = ABC_NtkRecDelayCompare(delayFromStruct, current->pinToPinDelay, nVars);
if(result == REC_EQUAL)
{
// when delay profile is equal, replace only if it has smaller cost.
if(costFromStruct < current->cost)
{
if(fTrim)
Abc_NtkRecDeleteSubGragh(p, current->obj);
Rec_ObjSet(p, current, pObj, delayFromStruct, costFromStruct, nVars);
}
else
{
if(fTrim)
Abc_NtkRecDeleteSubGragh(p, pObj);
}
break;
}
// when the new structure can dominate others, sweep them out of the library, delete them if required.
else if(result == REC_DOMINANCE)
{
if(fTrim)
Abc_NtkRecDeleteSubGragh(p, current->obj);
Rec_ObjSet(p, current, pObj, delayFromStruct, costFromStruct, nVars);
Abc_NtkRecSweepDominance(p,current,current->pNext,delayFromStruct, nVars, fTrim);
break;
}
// when the new structure is domianted by an existed one, don't store it.
else if (result == REC_BEDOMINANCED)
{
if(fTrim)
Abc_NtkRecDeleteSubGragh(p, pObj);
break;
}
// when the new structure's delay profile is big than the current, test the next one
else if (result == REC_BIG)
{
previous = current;
current = current->pNext;
}
// insert the new structure to the right position, sweep the ones it can dominate.
else if (result == REC_SMALL)
{
p->nAdded++;
entry = Rec_ObjAlloc(p, pObj, delayFromStruct, costFromStruct, nVars);
if(previous != NULL)
{
previous->pNext = entry;
entry->pNext = current;
}
else
{
entry->pNext = current;
entry->pCopy = (*ppSpot)->pCopy;
(*ppSpot)->pCopy = NULL;
*ppSpot = entry;
}
Abc_NtkRecSweepDominance(p,current,current->pNext,delayFromStruct, nVars, fTrim);
break;
}
else
assert(0);
}
}
/**Function*************************************************************
Synopsis [Build up the structure using library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Hop_Obj_t * Abc_NtkRecBuildUp_rec(Hop_Man_t* pMan, Abc_Obj_t* pObj, Vec_Ptr_t * vNodes)
{
Hop_Obj_t * pRes0, *pRes1, *pRes;
Abc_Obj_t *pRegular = Abc_ObjRegular(pObj);
if (Abc_NodeIsTravIdCurrent(pRegular) || pRegular->Type == ABC_OBJ_PI)
return (Hop_Obj_t *)Vec_PtrEntry(vNodes, pRegular->Id);
Abc_NodeSetTravIdCurrent(pRegular);
pRes0 = Abc_NtkRecBuildUp_rec(pMan, Abc_ObjFanin0(pRegular), vNodes);
pRes0 = Hop_NotCond(pRes0, pRegular->fCompl0);
pRes1 = Abc_NtkRecBuildUp_rec(pMan, Abc_ObjFanin1(pRegular), vNodes);
pRes1 = Hop_NotCond(pRes1, pRegular->fCompl1);
pRes = Hop_And(pMan, pRes0, pRes1);
Vec_PtrWriteEntry(vNodes,pRegular->Id,pRes);
return pRes;
}
/**Function*************************************************************
Synopsis [Derive the final network from the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut )
{
Rec_Obj_t *pCand, *pCandMin, **ppSpot;
Hop_Obj_t* pHopObj;
Abc_Obj_t* pAbcObj;
Abc_Ntk_t * pAig = s_pMan->pNtk;
int nLeaves, i, DelayMin = ABC_INFINITY , Delay = -ABC_INFINITY;
unsigned uCanonPhase;
Vec_Ptr_t * vNodes = s_pMan->vLabels;
int nVars = s_pMan->nVars;
char pCanonPerm[16];
unsigned *pInOut = s_pMan->pTemp1;
unsigned *pTemp = s_pMan->pTemp2;
int time = clock();
#ifdef Dervie
static FILE* pFile;
#endif
nLeaves = If_CutLeaveNum(pCut);
// if (nLeaves < 3)
// return Abc_NodeTruthToHop(pMan, pIfMan, pCut);
Kit_TruthCopy(pInOut, If_CutTruth(pCut), pCut->nLimit);
for (i = 0; i < nLeaves; i++)
pCanonPerm[i] = i;
uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints);
If_CutTruthStretch(pInOut, nLeaves, nVars);
ppSpot = Abc_NtkRecTableLookup( s_pMan, pInOut, nVars );
assert(*ppSpot != NULL);
DelayMin = ABC_INFINITY;
pCandMin = NULL;
// find the best one
for ( pCand = *ppSpot; pCand; pCand = pCand->pNext )
{
s_pMan->nFunsDelayComput++;
Delay = If_CutComputDelay(pIfMan, pCand, pCut, pCanonPerm ,nLeaves);
if ( DelayMin > Delay )
{
DelayMin = Delay;
pCandMin = pCand;
}
else if(Delay == DelayMin)
{
if(pCand->cost < pCandMin->cost)
pCandMin = pCand;
}
}
assert( pCandMin != NULL );
if ( s_pMan->vLabels == NULL )
s_pMan->vLabels = Vec_PtrStart( Abc_NtkObjNumMax(pAig) );
for (i = 0; i < nLeaves; i++)
{
pAbcObj = Abc_NtkPi( pAig, i );
pHopObj = Hop_IthVar(pMan, pCanonPerm[i]);
pHopObj = Hop_NotCond(pHopObj, ((uCanonPhase & (1 << i)) > 0));
Vec_PtrWriteEntry(s_pMan->vLabels, pAbcObj->Id, pHopObj);
}
Abc_NtkIncrementTravId(pAig);
//derive the best structure in the library.
pHopObj = Abc_NtkRecBuildUp_rec(pMan, pCandMin->obj, s_pMan->vLabels);
s_pMan->timeIfDerive += clock() - time;
s_pMan->timeIfTotal += clock() - time;
return Hop_NotCond(pHopObj, (pCut->fCompl)^(((uCanonPhase & (1 << nLeaves)) > 0)));
}
/**Function*************************************************************
Synopsis [Filter the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkRecFilter(int nLimit)
{
Abc_Obj_t * pObj;
void * temp;
Rec_Obj_t * previous = NULL, * entry = NULL, * pTemp;
int i, j, counter = 0;
Abc_Ntk_t * pNtk = s_pMan->pNtk;
int time = clock();
if (nLimit > 0)
{
Abc_NtkForEachPi( pNtk, pObj, i )
Abc_ObjSetMax( pObj, i+1 );
Abc_AigForEachAnd( pNtk, pObj, i )
Abc_ObjSetMax( pObj, ABC_MAX( Abc_ObjGetMax(Abc_ObjFanin0(pObj)), Abc_ObjGetMax(Abc_ObjFanin1(pObj)) ) );
for ( i = 0; i < s_pMan->nBins; i++ )
{
previous = NULL;
for ( entry = s_pMan->pBins[i]; entry; entry = entry->pCopy)
{
//make sure the structures with 2 variables stay in the library.
if(Abc_ObjGetMax(entry->obj) == 2)
continue;
counter = 0;
for ( pTemp = entry; pTemp; pTemp = pTemp->pNext)
{
counter++;
if(counter > nLimit)
break;
}
// only filter the functional classed with subgragh less than nLimit.
if(counter > nLimit)
{
previous = entry;
continue;
}
if(previous == NULL)
{
s_pMan->pBins[i] = entry->pCopy;
previous = NULL;
}
else
previous->pCopy = entry->pCopy;
s_pMan->nAddedFuncs--;
//delete all the subgragh.
for ( pTemp = entry; pTemp; pTemp = pTemp->pNext )
{
s_pMan->nAdded--;
Abc_NtkRecDeleteSubGragh(s_pMan, pTemp->obj);
Mem_FixedEntryRecycle(s_pMan->pMemObj, (char *)pTemp);
}
}
}
// clean level info.
Abc_NtkForEachObj( pNtk, pObj, i )
{
Abc_ObjClearMax( pObj );
}
}
// delete the dangling node.
Abc_AigCleanup((Abc_Aig_t * )pNtk->pManFunc);
// delete the PO with a constant node as its input.
i = 0;
j = Abc_NtkPoNum(pNtk) - 1;
while(1)
{
while(Abc_ObjChild0(Abc_NtkPo(pNtk, i)) != Abc_ObjNot( Abc_AigConst1(pNtk)))
i++;
while(Abc_ObjChild0(Abc_NtkPo(pNtk, j)) == Abc_ObjNot( Abc_AigConst1(pNtk)))
j--;
if(i > j)
break;
temp = Vec_PtrEntry(pNtk->vPos, i);
Vec_PtrWriteEntry(pNtk->vPos, i, Vec_PtrEntry(pNtk->vPos, j));
Vec_PtrWriteEntry(pNtk->vPos, j, temp);
}
//update the new size of PO vector.
pNtk->vPos->nSize = i;
s_pMan->timeTrim += clock() - time;
s_pMan->timeTotal += clock() - time;
}
/**Function*************************************************************
Synopsis [Test if the record is running.]
Description []
......@@ -102,7 +791,23 @@ int Abc_NtkRecIsRunning()
/**Function*************************************************************
Synopsis [Starts the record for the given network.]
Synopsis [Test if the record is working in trim mode.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Abc_NtkRecIsInTrimMode()
{
return (s_pMan != NULL && s_pMan->fTrim);
}
/**Function*************************************************************
Synopsis []
Description []
......@@ -118,7 +823,7 @@ int Abc_NtkRecVarNum()
/**Function*************************************************************
Synopsis [Starts the record for the given network.]
Synopsis []
Description []
......@@ -143,14 +848,16 @@ Vec_Int_t * Abc_NtkRecMemory()
SeeAlso []
***********************************************************************/
void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts )
void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts, int fTrim )
{
Abc_ManRec_t * p;
Abc_Obj_t * pObj, ** ppSpot;
Abc_Obj_t * pObj;
Rec_Obj_t** ppSpot;
char Buffer[10];
unsigned * pTruth;
int i, RetValue;
int clkTotal = clock(), clk;
int clkTotal = clock(), clk, timeInsert;
int testNum = 0;
assert( s_pMan == NULL );
if ( pNtk == NULL )
......@@ -194,7 +901,9 @@ void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts )
p->nWords = Kit_TruthWordNum( p->nVars );
p->nCuts = nCuts;
p->nVarsInit = nVars;
p->recObjSize = sizeof(Rec_Obj_t) + sizeof(char) * p->nVars;
p->pMemObj = Mem_FixedStart(p->recObjSize);
p->fTrim = fTrim;
// create elementary truth tables
p->vTtElems = Vec_PtrAlloc( 0 ); assert( p->vTtElems->pArray == NULL );
p->vTtElems->nSize = p->nVars;
......@@ -212,9 +921,10 @@ void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts )
Vec_PtrPush( p->vTtNodes, ABC_ALLOC(unsigned, p->nWords) );
// create hash table
p->nBins = 50011;
p->pBins = ABC_ALLOC( Abc_Obj_t *, p->nBins );
memset( p->pBins, 0, sizeof(Abc_Obj_t *) * p->nBins );
//p->nBins = 50011;
p->nBins =500011;
p->pBins = ABC_ALLOC( Rec_Obj_t *, p->nBins );
memset( p->pBins, 0, sizeof(Rec_Obj_t *) * p->nBins );
// set elementary tables
Kit_TruthFill( (unsigned *)Vec_PtrEntry(p->vTtNodes, 0), p->nVars );
......@@ -223,6 +933,7 @@ void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts )
// compute the tables
clk = clock();
Abc_AigForEachAnd( pNtk, pObj, i )
{
RetValue = Abc_NtkRecComputeTruth( pObj, p->vTtNodes, p->nVars );
......@@ -230,33 +941,33 @@ clk = clock();
}
p->timeTruth += clock() - clk;
Abc_NtkForEachPi( pNtk, pObj, i )
Abc_ObjSetMax( pObj, i+1 );
Abc_AigForEachAnd( pNtk, pObj, i )
Abc_ObjSetMax( pObj, ABC_MAX( Abc_ObjGetMax(Abc_ObjFanin0(pObj)), Abc_ObjGetMax(Abc_ObjFanin1(pObj)) ) );
// insert the PO nodes into the table
timeInsert = clock();
Abc_NtkForEachPo( pNtk, pObj, i )
{
p->nTried++;
p->nAdded++;
//if the PO's input is a constant, skip it.
if (Abc_ObjChild0(pObj) == Abc_ObjNot( Abc_AigConst1(pNtk)))
{
p->nTrimed++;
continue;
}
pObj = Abc_ObjFanin0(pObj);
pTruth = (unsigned *)Vec_PtrEntry( p->vTtNodes, pObj->Id );
// add the resulting truth table to the hash table
ppSpot = Abc_NtkRecTableLookup( p, pTruth, p->nVars );
assert( pObj->pData == NULL );
assert( pObj->pCopy == NULL );
if ( *ppSpot == NULL )
{
p->nAddedFuncs++;
*ppSpot = pObj;
Abc_NtkRecInsertToLookUpTable(p, ppSpot, pObj, Abc_ObjGetMax(pObj), p->fTrim);
}
else
p->timeInsert += clock() - timeInsert;
Abc_NtkForEachObj( pNtk, pObj, i )
{
pObj->pData = (*ppSpot)->pData;
(*ppSpot)->pData = (Hop_Obj_t *)pObj;
if ( !Abc_NtkRecAddCutCheckCycle_rec(*ppSpot, pObj) )
printf( "Loop!\n" );
}
Abc_ObjClearMax( pObj );
}
// temporaries
p->pBytes = ABC_ALLOC( int, 4*p->nWords );
p->pMints = ABC_ALLOC( int, 2*p->nVars );
......@@ -268,7 +979,7 @@ p->timeTruth += clock() - clk;
// set the manager
s_pMan = p;
p->timeTotal += clock() - clkTotal;
p->timeTotal += clock() - clkTotal;
}
/**Function*************************************************************
......@@ -286,14 +997,14 @@ void Abc_NtkRecDumpTruthTables( Abc_ManRec_t * p )
{
int nVars = 10;
FILE * pFile;
Abc_Obj_t * pObj;
Rec_Obj_t * pObj;
unsigned * pTruth;
int i;
pFile = fopen( "tt10.txt", "wb" );
for ( i = 0; i < p->nBins; i++ )
for ( pObj = p->pBins[i]; pObj; pObj = pObj->pCopy )
{
pTruth = (unsigned *)Vec_PtrEntry(p->vTtNodes, pObj->Id);
pTruth = Vec_PtrEntry(p->vTtNodes, pObj->Id);
if ( (int)Kit_TruthSupport(pTruth, nVars) != (1<<nVars)-1 )
continue;
Extra_PrintHex( pFile, pTruth, nVars );
......@@ -337,7 +1048,11 @@ void Abc_NtkRecStop()
Vec_PtrFree( s_pMan->vLabels );
if ( s_pMan->vCosts )
Vec_StrFree( s_pMan->vCosts );
if(s_pMan->pMemObj)
Mem_FixedStop(s_pMan->pMemObj, 0);
Vec_IntFree( s_pMan->vMemory );
// if(s_pMan->vFiltered)
// Vec_StrFree(s_pMan->vFiltered);
ABC_FREE( s_pMan );
s_pMan = NULL;
......@@ -366,9 +1081,6 @@ Abc_Ntk_t * Abc_NtkRecUse()
return pNtk;
}
static inline void Abc_ObjSetMax( Abc_Obj_t * pObj, int Value ) { assert( pObj->Level < 0xff ); pObj->Level = (Value << 8) | (pObj->Level & 0xff); }
static inline void Abc_ObjClearMax( Abc_Obj_t * pObj ) { pObj->Level = (pObj->Level & 0xff); }
static inline int Abc_ObjGetMax( Abc_Obj_t * pObj ) { return (pObj->Level >> 8) & 0xff; }
/**Function*************************************************************
......@@ -387,9 +1099,10 @@ void Abc_NtkRecPs()
int CounterS, CountersS[17] = {0};
Abc_ManRec_t * p = s_pMan;
Abc_Ntk_t * pNtk = p->pNtk;
Abc_Obj_t * pObj, * pEntry, * pTemp;
Rec_Obj_t * pEntry, * pTemp;
Abc_Obj_t * pObj;
int i;
int nVars = 6;
// set the max PI number
Abc_NtkForEachPi( pNtk, pObj, i )
Abc_ObjSetMax( pObj, i+1 );
......@@ -400,26 +1113,25 @@ void Abc_NtkRecPs()
for ( i = 0; i < p->nBins; i++ )
for ( pEntry = p->pBins[i]; pEntry; pEntry = pEntry->pCopy )
{
Counters[ Abc_ObjGetMax(pEntry) ]++;
assert(Abc_ObjGetMax(pEntry->obj) >= 2);
Counters[ Abc_ObjGetMax(pEntry->obj)]++;
Counter++;
for ( pTemp = pEntry; pTemp; pTemp = (Abc_Obj_t *)pTemp->pData )
for ( pTemp = pEntry; pTemp; pTemp = pTemp->pNext )
{
assert( Abc_ObjGetMax(pTemp) == Abc_ObjGetMax(pEntry) );
CountersS[ Abc_ObjGetMax(pTemp) ]++;
assert( Abc_ObjGetMax(pTemp->obj) == Abc_ObjGetMax(pEntry->obj) );
CountersS[ Abc_ObjGetMax(pTemp->obj) ]++;
CounterS++;
}
}
// printf( "Functions = %d. Expected = %d.\n", Counter, p->nAddedFuncs );
// printf( "Subgraphs = %d. Expected = %d.\n", CounterS, p->nAdded );
//printf( "Functions = %d. Expected = %d.\n", Counter, p->nAddedFuncs );
//printf( "Subgraphs = %d. Expected = %d.\n", CounterS, p->nAdded );
assert( Counter == p->nAddedFuncs );
assert( CounterS == p->nAdded );
// clean
Abc_NtkForEachObj( pNtk, pObj, i )
{
Abc_ObjClearMax( pObj );
}
printf( "The record with %d AND nodes in %d subgraphs for %d functions with %d inputs:\n",
Abc_NtkNodeNum(pNtk), Abc_NtkPoNum(pNtk), p->nAddedFuncs, Abc_NtkPiNum(pNtk) );
for ( i = 0; i <= 16; i++ )
......@@ -437,32 +1149,39 @@ void Abc_NtkRecPs()
printf( "Subgraphs filtered by isomorphism = %10d. (%6.2f %%)\n", p->nFilterSame, !p->nTried? 0 : 100.0*p->nFilterSame/p->nTried );
printf( "Subgraphs added = %10d. (%6.2f %%)\n", p->nAdded, !p->nTried? 0 : 100.0*p->nAdded/p->nTried );
printf( "Functions added = %10d. (%6.2f %%)\n", p->nAddedFuncs, !p->nTried? 0 : 100.0*p->nAddedFuncs/p->nTried );
p->timeOther = p->timeTotal - p->timeCollect - p->timeTruth - p->timeCanon;
ABC_PRTP( "Collecting nodes ", p->timeCollect, p->timeTotal );
if(s_pMan->fTrim)
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;
ABC_PRTP( "Collecting nodes ", p->timeCollect, p->timeTotal);
ABC_PRTP( "Computing truth ", p->timeTruth, p->timeTotal );
ABC_PRTP( "Canonicizing ", p->timeCanon, p->timeTotal );
ABC_PRTP( "Building ", p->timeBuild, p->timeTotal );
ABC_PRTP( "Insert ", p->timeInsert, p->timeTotal);
if(s_pMan->fTrim)
ABC_PRTP( "Filter ", p->timeTrim, p->timeTotal);
ABC_PRTP( "Other ", p->timeOther, p->timeTotal );
ABC_PRTP( "TOTAL ", p->timeTotal, p->timeTotal );
if ( p->nFunsFound )
{
printf("\n");
printf( "During rewriting found = %d and not found = %d functions.\n", p->nFunsFound, p->nFunsNotFound );
}
/**Function*************************************************************
Synopsis [Filters the current record.]
Description []
SideEffects []
SeeAlso []
printf( "Functions tried = %10d. (%6.2f %%)\n", p->nFunsTried, !p->nFunsTried? 0 : 100.0*p->nFunsTried/p->nFunsTried );
printf( "Functions filtered by support = %10d. (%6.2f %%)\n", p->nFunsFilteredBysupport, !p->nFunsFilteredBysupport? 0 : 100.0*p->nFunsFilteredBysupport/p->nFunsTried );
printf( "Functions not found in lib = %10d. (%6.2f %%)\n", p->nFunsNotFound, !p->nFunsNotFound? 0 : 100.0*p->nFunsNotFound/p->nFunsTried );
printf( "Functions founded = %10d. (%6.2f %%)\n", p->nFunsFound, !p->nFunsFound? 0 : 100.0*p->nFunsFound/p->nFunsTried );
printf( "Functions delay computed = %10d. Ratio = %6.2f.\n", p->nFunsDelayComput, !p->nFunsDelayComput? 0 : 1.0*p->nFunsDelayComput/p->nFunsFound );
p->timeIfOther = p->timeIfTotal - p->timeIfCanonicize - p->timeIfComputDelay -p->timeIfDerive;
ABC_PRTP( "Canonicize ", p->timeIfCanonicize, p->timeIfTotal );
ABC_PRTP( "Compute Delay ", p->timeIfComputDelay, p->timeIfTotal );
ABC_PRTP( "Derive ", p->timeIfDerive, p->timeIfTotal );
ABC_PRTP( "Other ", p->timeIfOther, p->timeIfTotal );
ABC_PRTP( "TOTAL ", p->timeIfTotal, p->timeIfTotal );
}
***********************************************************************/
void Abc_NtkRecFilter( int iVar, int iPlus )
{
}
/**Function*************************************************************
Synopsis [Returns the hash key.]
......@@ -494,10 +1213,10 @@ static inline unsigned Abc_NtkRecTableHash( unsigned * pTruth, int nVars, int nB
SeeAlso []
***********************************************************************/
Abc_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t * p, unsigned * pTruth, int nVars )
Rec_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t * p, unsigned * pTruth, int nVars )
{
static int s_Primes[10] = { 1291, 1699, 2357, 4177, 5147, 5647, 6343, 7103, 7873, 8147 };
Abc_Obj_t ** ppSpot, * pEntry;
Rec_Obj_t ** ppSpot, * pEntry;
ppSpot = p->pBins + Abc_NtkRecTableHash( pTruth, nVars, p->nBins, s_Primes );
for ( pEntry = *ppSpot; pEntry; ppSpot = &pEntry->pCopy, pEntry = pEntry->pCopy )
if ( Kit_TruthIsEqualWithPhase((unsigned *)Vec_PtrEntry(p->vTtNodes, pEntry->Id), pTruth, nVars) )
......@@ -815,7 +1534,8 @@ int Abc_NtkRecAddCut( If_Man_t * pIfMan, If_Obj_t * pRoot, If_Cut_t * pCut )
static int s_MaxSize[16] = { 0 };
char Buffer[40], Name[20], Truth[20];
char pCanonPerm[16];
Abc_Obj_t * pObj = NULL, * pFanin0, * pFanin1, ** ppSpot, * pObjPo;
Abc_Obj_t * pObj = NULL, * pFanin0, * pFanin1, * pObjPo;
Rec_Obj_t ** ppSpot;
Abc_Ntk_t * pAig = s_pMan->pNtk;
If_Obj_t * pIfObj;
Vec_Ptr_t * vNodes = s_pMan->vNodes;
......@@ -824,14 +1544,12 @@ int Abc_NtkRecAddCut( If_Man_t * pIfMan, If_Obj_t * pRoot, If_Cut_t * pCut )
unsigned * pTruth;
int i, RetValue, nNodes, nNodesBeg, nInputs = s_pMan->nVars, nLeaves = If_CutLeaveNum(pCut);
unsigned uCanonPhase;
int clk;
int clk, timeInsert, timeBuild;
assert( nInputs <= 16 );
assert( nInputs == (int)pCut->nLimit );
s_pMan->nTried++;
// skip small cuts
if ( nLeaves < 3 )
if ( nLeaves < 2 )
{
s_pMan->nFilterSize++;
return 1;
......@@ -840,6 +1558,7 @@ int Abc_NtkRecAddCut( If_Man_t * pIfMan, If_Obj_t * pRoot, If_Cut_t * pCut )
// collect internal nodes and skip redundant cuts
clk = clock();
RetValue = Abc_NtkRecCollectNodes( pIfMan, pRoot, pCut, vNodes );
s_pMan->timeCollect += clock() - clk;
if ( !RetValue )
{
......@@ -857,9 +1576,11 @@ s_pMan->timeCollect += clock() - clk;
// compute truth table and skip the redundant structures
clk = clock();
RetValue = Abc_NtkRecCutTruth( vNodes, nLeaves, s_pMan->vTtTemps, s_pMan->vTtElems );
s_pMan->timeTruth += clock() - clk;
s_pMan->timeTruth += clock() - clk;
if ( !RetValue )
{
//fprintf(file,"redundant structures\n");
//fclose(file);
s_pMan->nFilterTruth++;
return 1;
}
......@@ -868,16 +1589,18 @@ s_pMan->timeTruth += clock() - clk;
Kit_TruthCopy( pInOut, (unsigned *)pRoot->pCopy, nInputs );
// set permutation
for ( i = 0; i < nInputs; i++ )
for ( i = 0; i < nLeaves; i++ )
pCanonPerm[i] = i;
// semi-canonicize the truth table
clk = clock();
uCanonPhase = Kit_TruthSemiCanonicize( pInOut, pTemp, nInputs, pCanonPerm, (short *)s_pMan->pMints );
s_pMan->timeCanon += clock() - clk;
uCanonPhase = Kit_TruthSemiCanonicize( pInOut, pTemp, nLeaves, pCanonPerm, (short *)s_pMan->pMints );
If_CutTruthStretch(pInOut, nLeaves, s_pMan->nVars);
s_pMan->timeCanon += clock() - clk;
// pCanonPerm and uCanonPhase show what was the variable corresponding to each var in the current truth
// go through the variables in the new truth table
timeBuild = clock();
for ( i = 0; i < nLeaves; i++ )
{
// get hold of the corresponding leaf
......@@ -887,19 +1610,6 @@ s_pMan->timeCanon += clock() - clk;
pObj = Abc_ObjNotCond( pObj, (uCanonPhase & (1 << i)) );
// map them
pIfObj->pCopy = pObj;
/*
if ( pRoot->Id == 2639 )
{
unsigned uSupp;
printf( "Node %6d : ", pIfObj->Id );
printf( "Support " );
uSupp = Kit_TruthSupport(Vec_PtrEntry( s_pMan->vTtNodes, Abc_ObjRegular(pObj)->Id ), nInputs);
Extra_PrintBinary( stdout, &uSupp, nInputs );
printf( " " );
Extra_PrintBinary( stdout, Vec_PtrEntry( s_pMan->vTtNodes, Abc_ObjRegular(pObj)->Id ), 1<<6 );
printf( "\n" );
}
*/
}
// build the node and compute its truth table
......@@ -932,8 +1642,8 @@ s_pMan->timeCanon += clock() - clk;
}
}
}
assert(pObj);
s_pMan->timeBuild = clock() - timeBuild;
pTruth = (unsigned *)Vec_PtrEntry( s_pMan->vTtNodes, pObj->Id );
if ( Kit_TruthSupport(pTruth, nInputs) != Kit_BitMask(nLeaves) )
{
......@@ -957,7 +1667,7 @@ s_pMan->timeCanon += clock() - clk;
s_pMan->nFilterSame++;
return 1;
}
s_pMan->nAdded++;
//s_pMan->nAdded++;
// create PO for this node
pObjPo = Abc_NtkCreatePo(pAig);
......@@ -977,25 +1687,109 @@ s_pMan->timeCanon += clock() - clk;
Abc_ObjAssignName( pObjPo, Buffer, NULL );
// add the resulting truth table to the hash table
timeInsert = clock();
ppSpot = Abc_NtkRecTableLookup( s_pMan, pTruth, nInputs );
assert( pObj->pData == NULL );
assert( pObj->pCopy == NULL );
Abc_NtkRecInsertToLookUpTable(s_pMan, ppSpot, pObj, nLeaves, s_pMan->fTrim);
s_pMan->timeInsert += clock() - timeInsert;
return 1;
}
/**Function*************************************************************
Synopsis [Computes the delay using library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut)
{
int timeDelayComput, timeTotal = clock(), timeCanonicize;
int nLeaves, i, DelayMin = ABC_INFINITY , Delay = -ABC_INFINITY;
char pCanonPerm[16];
unsigned uCanonPhase;
unsigned* pTruthRec;
Rec_Obj_t *pCand, *pCandMin, **ppSpot;
Abc_Ntk_t *pAig = s_pMan->pNtk;
unsigned *pInOut = s_pMan->pTemp1;
unsigned *pTemp = s_pMan->pTemp2;
int nVars = s_pMan->nVars;
assert( s_pMan != NULL );
nLeaves = If_CutLeaveNum(pCut);
s_pMan->nFunsTried++;
assert( nLeaves >= 2 && nLeaves <= nVars );
Kit_TruthCopy(pInOut, If_CutTruth(pCut), nLeaves);
//if not every variables are in the support, skip this cut.
if ( Kit_TruthSupport(pInOut, nLeaves) != Kit_BitMask(nLeaves) )
{
s_pMan->nFunsFilteredBysupport++;
pCut->fUser = 1;
pCut->Cost = IF_COST_MAX;
return ABC_INFINITY;
}
timeCanonicize = clock();
//canonicize
for (i = 0; i < nLeaves; i++)
pCanonPerm[i] = i;
uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints);
If_CutTruthStretch(pInOut, nLeaves, nVars);
s_pMan->timeIfCanonicize += clock() - timeCanonicize;
ppSpot = Abc_NtkRecTableLookup( s_pMan, pInOut, nVars );
assert (!(*ppSpot == NULL && nLeaves == 2));
//functional class not found in the library.
if ( *ppSpot == NULL )
{
s_pMan->nAddedFuncs++;
*ppSpot = pObj;
s_pMan->nFunsNotFound++;
pCut->Cost = IF_COST_MAX;
pCut->fUser = 1;
return ABC_INFINITY;
}
else
s_pMan->nFunsFound++;
// make sure the truth table is the same
pTruthRec = (unsigned*)Vec_PtrEntry( s_pMan->vTtNodes, (*ppSpot)->Id );
if ( !Kit_TruthIsEqualWithPhase( pTruthRec, pInOut, nLeaves ) )
{
pObj->pData = (*ppSpot)->pData;
(*ppSpot)->pData = pObj;
if ( !Abc_NtkRecAddCutCheckCycle_rec(*ppSpot, pObj) )
printf( "Loop!\n" );
assert( 0 );
return -1;
s_pMan->nIfMapError++;
}
return 1;
// mark as user cut.
pCut->fUser = 1;
DelayMin = ABC_INFINITY;
pCandMin = NULL;
timeDelayComput = clock();
//find the best structure of the functional class.
for ( pCand = *ppSpot; pCand; pCand = pCand->pNext )
{
s_pMan->nFunsDelayComput++;
Delay = If_CutComputDelay(p, pCand, pCut, pCanonPerm ,nLeaves);
if ( DelayMin > Delay )
{
// printf( "%d ", Cost );
DelayMin = Delay;
pCandMin = pCand;
}
else if(Delay == DelayMin)
{
if(pCand->cost < pCandMin->cost)
pCandMin = pCand;
}
}
s_pMan->timeIfComputDelay += clock() - timeDelayComput;
assert( pCandMin != NULL );
for ( i = 0; i < nLeaves; i++ )
{
pCut->pPerm[pCanonPerm[i]] = pCandMin->pinToPinDelay[i];
}
s_pMan->timeIfTotal += clock() - timeTotal;
pCut->Cost = pCandMin->cost;
return DelayMin;
}
/**Function*************************************************************
Synopsis [Labels the record AIG with the corresponding new AIG nodes.]
......@@ -1007,7 +1801,7 @@ s_pMan->timeCanon += clock() - clk;
SeeAlso []
***********************************************************************/
Abc_Obj_t * Abc_NtkRecStrashNodeLabel_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, int fBuild, Vec_Ptr_t * vLabels )
/*Abc_Obj_t * Abc_NtkRecStrashNodeLabel_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, int fBuild, Vec_Ptr_t * vLabels )
{
Abc_Obj_t * pFanin0New, * pFanin1New, * pLabel;
assert( !Abc_ObjIsComplement(pObj) );
......@@ -1033,7 +1827,7 @@ Abc_Obj_t * Abc_NtkRecStrashNodeLabel_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj
}
Vec_PtrWriteEntry( vLabels, pObj->Id, pLabel );
return pLabel;
}
}*/
/**Function*************************************************************
......@@ -1046,7 +1840,7 @@ Abc_Obj_t * Abc_NtkRecStrashNodeLabel_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj
SeeAlso []
***********************************************************************/
int Abc_NtkRecStrashNodeCount_rec( Abc_Obj_t * pObj, Vec_Str_t * vCosts, Vec_Ptr_t * vLabels )
/*int Abc_NtkRecStrashNodeCount_rec( Abc_Obj_t * pObj, Vec_Str_t * vCosts, Vec_Ptr_t * vLabels )
{
int Cost0, Cost1;
if ( Vec_PtrEntry( vLabels, pObj->Id ) )
......@@ -1062,7 +1856,7 @@ int Abc_NtkRecStrashNodeCount_rec( Abc_Obj_t * pObj, Vec_Str_t * vCosts, Vec_Ptr
Cost1 = Abc_NtkRecStrashNodeCount_rec( Abc_ObjFanin1(pObj), vCosts, vLabels );
Vec_StrWriteEntry( vCosts, pObj->Id, (char)(Cost0 + Cost1 + 1) );
return Cost0 + Cost1 + 1;
}
}*/
/**Function*************************************************************
......@@ -1076,7 +1870,7 @@ int Abc_NtkRecStrashNodeCount_rec( Abc_Obj_t * pObj, Vec_Str_t * vCosts, Vec_Ptr
SeeAlso []
***********************************************************************/
int Abc_NtkRecStrashNode( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, unsigned * pTruth, int nVars )
/*int Abc_NtkRecStrashNode( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, unsigned * pTruth, int nVars )
{
char pCanonPerm[16];
Abc_Ntk_t * pAig = s_pMan->pNtk;
......@@ -1201,7 +1995,11 @@ int Abc_NtkRecStrashNode( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, unsigned * pTru
// complement
pObj->pCopy = Abc_ObjNotCond( pObj->pCopy, fCompl );
return 1;
}
}*/
////////////////////////////////////////////////////////////////////////
......
src/map/if/if.h
......@@ -105,6 +105,7 @@ struct If_Par_t_
float WireDelay; // wire delay
// internal parameters
int fDelayOpt; // special delay optimization
int fUserRecLib; // use recorded library
int fAreaOnly; // area only mode
int fTruth; // truth table computation enabled
int fUsePerm; // use permutation (delay info)
......@@ -497,6 +498,9 @@ extern Vec_Int_t * If_ManCollectMappingInt( If_Man_t * p );
extern int If_ManCountSpecialPos( If_Man_t * p );
/*=== abcRec.c ============================================================*/
extern int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut);
// othe packages
extern int Bat_ManCellFuncLookup( unsigned * pTruth, int nVars, int nLeaves );
......
src/map/if/ifMap.c
......@@ -20,8 +20,8 @@
#include "if.h"
ABC_NAMESPACE_IMPL_START
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
......@@ -156,8 +156,10 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep
/// if ( p->pPars->pLutStruct )
/// pCut->Delay = If_CutDelayLutStruct( p, pCut, p->pPars->pLutStruct, p->pPars->WireDelay );
// else if ( p->pPars->fDelayOpt )
if ( p->pPars->fDelayOpt )
pCut->Delay = If_CutDelaySopCost( p, pCut );
if ( p->pPars->fUserRecLib )
pCut->Delay = If_CutDelayRecCost(p, pCut);
else if(p->pPars->fDelayOpt)
pCut->Delay = If_CutDelaySopCost(p,pCut);
else
pCut->Delay = If_CutDelay( p, pObj, pCut );
// assert( pCut->Delay <= pObj->Required + p->fEpsilon );
......@@ -224,8 +226,10 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep
/// if ( p->pPars->pLutStruct )
/// pCut->Delay = If_CutDelayLutStruct( p, pCut, p->pPars->pLutStruct, p->pPars->WireDelay );
// else if ( p->pPars->fDelayOpt )
if ( p->pPars->fDelayOpt )
pCut->Delay = If_CutDelaySopCost( p, pCut );
if ( p->pPars->fUserRecLib )
pCut->Delay = If_CutDelayRecCost(p, pCut);
else if (p->pPars->fDelayOpt)
pCut->Delay = If_CutDelaySopCost(p, pCut);
else
pCut->Delay = If_CutDelay( p, pObj, pCut );
// Abc_Print( 1, "%.2f ", pCut->Delay );
......@@ -252,9 +256,12 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep
// 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);
}
assert( p->pPars->fSeqMap || If_ObjCutBest(pObj)->nLeaves > 1 );
// ref the selected cut
if ( Mode && pObj->nRefs > 0 )
If_CutAreaRef( p, If_ObjCutBest(pObj) );
......@@ -266,6 +273,7 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep
If_ObjForEachCut( pObj, pCut, i )
p->pPars->pFuncUser( p, pObj, pCut );
// free the cuts
If_ManDerefNodeCutSet( p, pObj );
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment