Skip to content

A
abc
Commit 01bea8ef by Alan Mishchenko
Options

Enabling additional stat printouts.

parent 2469058b
Showing with 117 additions and 4 deletions
src/base/abci/abcRec3.c
......@@ -57,12 +57,14 @@ struct Lms_Man_t_
// internal data for library construction
Gia_Man_t * pGia; // the record
Vec_Mem_t * vTtMem; // truth table memory and hash table
Vec_Mem_t * vTtMem2; // truth table memory and hash table
Vec_Int_t * vTruthIds; // truth table IDs of each PO
// internal data for AIG level minimization (allocated the first time it is called)
Vec_Int_t * vTruthPo; // first PO where this canonicized truth table was seen
Vec_Wrd_t * vDelays; // pin-to-pin delays of each PO
Vec_Str_t * vAreas; // number of AND gates in each PO
Vec_Int_t * vFreqs; // subgraph usage frequencies
Vec_Int_t * vTruthFreqs; // truth table usage frequencies
// temporaries
Vec_Ptr_t * vNodes; // the temporary nodes
Vec_Ptr_t * vLabelsP; // temporary storage for HOP node labels
......@@ -316,7 +318,9 @@ Lms_Man_t * Lms_ManStart( Gia_Man_t * pGia, int nVars, int nCuts, int fFuncOnly,
p->fFuncOnly = fFuncOnly;
// internal data for library construction
p->vTtMem = Vec_MemAlloc( p->nWords, 12 ); // 32 KB/page for 6-var functions
p->vTtMem2 = Vec_MemAlloc( p->nWords, 12 ); // 32 KB/page for 6-var functions
Vec_MemHashAlloc( p->vTtMem, 10000 );
Vec_MemHashAlloc( p->vTtMem2, 10000 );
if ( fFuncOnly )
return p;
p->vTruthIds = Vec_IntAlloc( 10000 );
......@@ -367,11 +371,14 @@ void Lms_ManStop( Lms_Man_t * p )
Vec_WrdFreeP( &p->vDelays );
Vec_StrFreeP( &p->vAreas );
Vec_IntFreeP( &p->vFreqs );
Vec_IntFreeP( &p->vTruthFreqs );
// internal data for library construction
Vec_IntFreeP( &p->vTruthIds );
Vec_MemHashFree( p->vTtMem );
Vec_MemHashFree( p->vTtMem2 );
Vec_MemFree( p->vTtMem );
Gia_ManStop( p->pGia );
Vec_MemFree( p->vTtMem2 );
Gia_ManStopP( &p->pGia );
ABC_FREE( p );
}
void Lms_ManPrepare( Lms_Man_t * p )
......@@ -420,12 +427,107 @@ void Lms_ManPrintFuncStats( Lms_Man_t * p )
printf( "Inputs = %2d. Funcs = %8d. Subgrs = %8d. Ratio = %6.2f.\n", i, Counters[i], CountersS[i], 1.0*CountersS[i]/Counters[i] );
Vec_StrFree( vSupps );
}
void Lms_ManPrintFreqStats( Lms_Man_t * p )
{
int CountDsdNpn[3] = {0}; // full/part/none
int CountDsdAll[3] = {0}; // full/part/none
int CountStepNpn[3] = {0}; // full/1step/complex
int CountStepAll[3] = {0}; // full/1step/complex
char pBuffer[1000];
int nSuppSize;
int nNonDecSize;
word * pTruth;
int i, Freq, Status;
printf( "Cuts = %10d. ", p->nTried );
printf( "Funcs = %10d (%6.2f %%). ", Vec_MemEntryNum(p->vTtMem2), 100.0*Vec_MemEntryNum(p->vTtMem2)/p->nTried );
printf( "Class = %10d (%6.2f %%). ", Vec_MemEntryNum(p->vTtMem), 100.0*Vec_MemEntryNum(p->vTtMem)/p->nTried );
printf( "\n" );
// return;
Vec_IntForEachEntry( p->vTruthFreqs, Freq, i )
{
pTruth = Vec_MemReadEntry(p->vTtMem, i);
/*
printf( "%6d -- %6d : ", i, Freq );
Kit_DsdWriteFromTruth( pBuffer, (unsigned *)pTruth, p->nVars );
printf( "%s\n", pBuffer );
*/
nSuppSize = Abc_TtSupportSize( pTruth, p->nVars );
nNonDecSize = Dau_DsdDecompose( pTruth, p->nVars, 0, 0, pBuffer );
if ( nNonDecSize == 0 )
{
CountDsdNpn[0]++;
CountDsdAll[0] += Freq;
}
else if ( nNonDecSize < nSuppSize )
{
CountDsdNpn[1]++;
CountDsdAll[1] += Freq;
}
else // non-dec
{
CountDsdNpn[2]++;
CountDsdAll[2] += Freq;
}
if ( nNonDecSize == 0 )
{
CountStepNpn[0]++;
CountStepAll[0] += Freq;
continue;
}
// check the non dec core
Status = Dau_DsdCheck1Step( pTruth, nNonDecSize );
if ( Status >= 0 )
{
CountStepNpn[1]++;
CountStepAll[1] += Freq;
}
else
{
assert( Status == -2 );
CountStepNpn[2]++;
CountStepAll[2] += Freq;
}
}
// print the results
printf( "NPN: " );
printf( "Full = %6.2f %% ", 100.0 * CountDsdNpn[0] / Vec_MemEntryNum(p->vTtMem) );
printf( "Part = %6.2f %% ", 100.0 * CountDsdNpn[1] / Vec_MemEntryNum(p->vTtMem) );
printf( "None = %6.2f %% ", 100.0 * CountDsdNpn[2] / Vec_MemEntryNum(p->vTtMem) );
// printf( "\n" );
printf( " " );
// print the results
printf( "All: " );
printf( "Full = %6.2f %% ", 100.0 * CountDsdAll[0] / p->nTried );
printf( "Part = %6.2f %% ", 100.0 * CountDsdAll[1] / p->nTried );
printf( "None = %6.2f %% ", 100.0 * CountDsdAll[2] / p->nTried );
printf( "\n" );
// print the results
printf( "NPN: " );
printf( "Full = %6.2f %% ", 100.0 * CountStepNpn[0] / Vec_MemEntryNum(p->vTtMem) );
printf( "1stp = %6.2f %% ", 100.0 * CountStepNpn[1] / Vec_MemEntryNum(p->vTtMem) );
printf( "Comp = %6.2f %% ", 100.0 * CountStepNpn[2] / Vec_MemEntryNum(p->vTtMem) );
// printf( "\n" );
printf( " " );
// print the results
printf( "All: " );
printf( "Full = %6.2f %% ", 100.0 * CountStepAll[0] / p->nTried );
printf( "1stp = %6.2f %% ", 100.0 * CountStepAll[1] / p->nTried );
printf( "Comp = %6.2f %% ", 100.0 * CountStepAll[2] / p->nTried );
printf( "\n" );
}
void Lms_ManPrint( Lms_Man_t * p )
{
// Gia_ManPrintStats( p->pGia, 0, 0 );
printf( "Library with %d vars has %d classes and %d AIG subgraphs with %d AND nodes.\n",
p->nVars, Vec_MemEntryNum(p->vTtMem), p->nAdded, p->pGia ? Gia_ManAndNum(p->pGia) : 0 );
Lms_ManPrintFreqStats( p );
Lms_ManPrintFuncStats( p );
p->nAddedFuncs = Vec_MemEntryNum(p->vTtMem);
......@@ -609,6 +711,9 @@ int Abc_NtkRecAddCut3( If_Man_t * pIfMan, If_Obj_t * pRoot, If_Cut_t * pCut )
return 1;
}
if ( p->vTtMem2 )
Vec_MemHashInsert( p->vTtMem2, If_CutTruthW(pCut) );
// semi-canonicize truth table
clk = clock();
memcpy( p->pTemp1, If_CutTruthW(pCut), p->nWords * sizeof(word) );
......@@ -625,7 +730,14 @@ p->timeCanon += clock() - clk;
{
clk = clock();
// add the resulting truth table to the hash table
Vec_MemHashInsert( p->vTtMem, p->pTemp1 );
Index = Vec_MemHashInsert( p->vTtMem, p->pTemp1 );
if ( p->vTruthFreqs == NULL )
p->vTruthFreqs = Vec_IntAlloc( 1000 );
assert( Index <= Vec_IntSize(p->vTruthFreqs) );
if ( Index < Vec_IntSize(p->vTruthFreqs) )
Vec_IntAddToEntry( p->vTruthFreqs, Index, 1 );
else
Vec_IntPush( p->vTruthFreqs, 1 );
p->nAdded++;
p->timeInsert += clock() - clk;
return 1;
......
src/opt/dau/dau.h
......@@ -39,8 +39,8 @@
ABC_NAMESPACE_HEADER_START
#define DAU_MAX_VAR 12 // should be 6 or more
#define DAU_MAX_STR 256
#define DAU_MAX_VAR 16 // should be 6 or more
#define DAU_MAX_STR 1000
#define DAU_MAX_WORD (1<<(DAU_MAX_VAR-6))
////////////////////////////////////////////////////////////////////////
......@@ -84,6 +84,7 @@ extern word Dau_Dsd6ToTruth( char * p );
extern void Dau_DsdNormalize( char * p );
extern int Dau_DsdCountAnds( char * pDsd );
extern void Dau_DsdTruthCompose_rec( word * pFunc, word pFanins[DAU_MAX_VAR][DAU_MAX_WORD], word * pRes, int nVars, int nWordsR );
extern int Dau_DsdCheck1Step( word * pTruth, int nVarsInit );
/*=== dauMerge.c ==========================================================*/
extern void Dau_DsdRemoveBraces( char * pDsd, int * pMatches );
......
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