Experiments with LUT mapping for small functions.

1 files changed, 87 insertions, 4 deletions

diff --git a/src/aig/gia/giaMinLut2.c b/src/aig/gia/giaMinLut2.c
index 425d9718..26310d34 100644
--- a/src/aig/gia/giaMinLut2.c
+++ b/src/aig/gia/giaMinLut2.c
@@ -520,7 +520,7 @@ static inline word Abc_TtGia6Min_rec( Gia_Man_t * p, word uF, word uR, int nVars
     word uF0, uF1, uR0, uR1, uRes0, uRes1, uRes2; int i, Var, iLit0, iLit1;
     assert( nVars <= 6 );
     assert( (uF & uR) == 0 );
-    *piLit = -1;
+    *piLit = 0;
     if ( !uF && !uR )
         return TT_UNDEF;
     if ( !uF && !~uR )
@@ -595,7 +595,7 @@ word * Abc_TtGiaMin_rec( Gia_Man_t * p, word * pF, word * pR, int nVars, Vec_Wrd
 {
     int i, Entry, Var, iLit0, iLit1, nWords = Abc_TtWordNum(nVars);
     word * pRes0, * pRes1, * pRes2 = Vec_WrdFetch( vMemory, nWords );
-    *piLit = -1;
+    *piLit = 0;
     if ( nVars <= 6 )
     {
         pRes2[0] = Abc_TtGia6Min_rec( p, pF[0], pR[0], nVars, vNodes, piLit, pPerm );
@@ -694,7 +694,7 @@ word * Abc_TtGiaMin_rec( Gia_Man_t * p, word * pF, word * pR, int nVars, Vec_Wrd
     }
     return pRes2;
 }
-Gia_Man_t * Abc_TtGiaMinArray( word * p, int nOuts, int nVars, int * pnNodes, int fVerbose, int * pIPerm )
+Gia_Man_t * Abc_TtGiaMinArray( word * p, int nVars, int nOuts, int * pnNodes, int fVerbose, int * pIPerm )
 {
     Gia_Man_t * pNew, * pTemp;
     int o, i, iLit, nWords = Abc_TtWordNum(nVars);
@@ -743,6 +743,50 @@ Gia_Man_t * Abc_TtGiaMinArray( word * p, int nOuts, int nVars, int * pnNodes, in
     Gia_ManStop( pTemp );
     return pNew;
 }
+Gia_Man_t * Abc_TtGiaMinArrayNew( word * p, int nVars, int nOuts, int * pnNodes, int fVerbose, int * pIPerm )
+{
+    Gia_Man_t * pNew, * pTemp;
+    int o, i, iLit, nWords = Abc_TtWordNum(nVars);
+    word * pF = ABC_ALLOC( word, nWords );
+    word * pR = ABC_ALLOC( word, nWords );
+    Vec_Wrd_t * vMemory = Vec_WrdAlloc( 100 );
+    Vec_Wrd_t * vNodes  = Vec_WrdAlloc( 100 );
+    Vec_Wec_t * vNodes2 = Vec_WecStart( nVars+1 );
+    Vec_WrdGrow( vMemory, 1 << 20 );
+    pNew = Gia_ManStart( 1000 );
+    pNew->pName = Abc_UtilStrsav( "muxes" );
+    for ( i = 0; i < nVars; i++ )
+        Gia_ManAppendCi(pNew);
+    Gia_ManHashAlloc( pNew );
+
+    for ( o = 0; o < nOuts; o++ )
+    {
+        word * pCare = p + nOuts*nWords;
+        word * pTruth = p + o*nWords;
+        Abc_TtAnd( pF, pCare, pTruth, nWords, 0 );
+        Abc_TtSharp( pR, pCare, pTruth, nWords );
+        for ( i = nVars; i < 6; i++ )
+            assert( !Abc_Tt6HasVar(pF[0], i) && !Abc_Tt6HasVar(pR[0], i) );
+        Abc_TtGiaMin_rec( pNew, pF, pR, nVars, vMemory, vNodes, vNodes2, &iLit, pIPerm );
+        Gia_ManAppendCo( pNew, iLit );
+    }
+    if ( fVerbose )
+    printf( "Nodes = %5d.  Nodes2 = %5d.  Total = %5d.    ", 
+        Vec_WrdSize(vNodes), Vec_WecSizeSize(vNodes2), Vec_WrdSize(vNodes) + Vec_WecSizeSize(vNodes2) );
+    //printf( "Memory %d (Truth table %d)\n", Vec_WrdSize(vMemory), nWords );
+    if ( pnNodes )
+        *pnNodes = Vec_WrdSize(vNodes) + Vec_WecSizeSize(vNodes2);
+    Vec_WrdFree( vMemory );
+    Vec_WrdFree( vNodes );
+    Vec_WecFree( vNodes2 );
+    ABC_FREE( pF );
+    ABC_FREE( pR );
+
+    Gia_ManHashStop( pNew );
+    pNew = Gia_ManCleanup( pTemp = pNew );
+    Gia_ManStop( pTemp );
+    return pNew;
+}
 
 
 /**Function*************************************************************
@@ -950,7 +994,7 @@ Gia_Man_t * Gia_TryPermOpt( word * pTruths, int nIns, int nOuts, int nWords, int
     for ( r = 0; r < nRounds; r++ )
     {
         int nNodesAll = Gia_ManPermuteTreeOne( pTruthDup, nIns, nOuts, nWords, r>0, pIPerm, 0, fVerbose );
-        Gia_Man_t * pTemp = Abc_TtGiaMinArray( pTruthDup, nOuts, nIns, NULL, 0, pIPerm );
+        Gia_Man_t * pTemp = Abc_TtGiaMinArray( pTruthDup, nIns, nOuts, NULL, 0, pIPerm );
         nNodes2 = Gia_ManAndNum(pTemp);
         if ( nNodesBest > nNodes2 )
         {
@@ -975,6 +1019,45 @@ Gia_Man_t * Gia_TryPermOpt( word * pTruths, int nIns, int nOuts, int nWords, int
         Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
     return pBest;
 }
+Gia_Man_t * Gia_TryPermOptNew( word * pTruths, int nIns, int nOuts, int nWords, int nRounds, int fVerbose )
+{
+    abctime clk = Abc_Clock();
+    Gia_Man_t * pTemp, * pBest = NULL;
+    word * pTruthDup = Abc_TtDup( pTruths, (nOuts+1)*nWords, 0 );
+    int pIPermBest[TREE_MAX_VARS] = {0};
+    int pIPerm[TREE_MAX_VARS] = {0};
+    int r, rBest = -1, nNodes2 = -1, nNodesBest = ABC_INFINITY;
+    //srand( time(NULL) );
+    Gia_ManRandom(1);
+    for ( r = 0; r < nRounds; r++ )
+    {
+        int nNodesAll = Gia_ManPermuteTreeOne( pTruthDup, nIns, nOuts, nWords, r>0, pIPerm, 0, fVerbose );
+        Abc_TtPermute( pTruthDup + nOuts*nWords, pIPerm, nIns );
+        pTemp = Abc_TtGiaMinArrayNew( pTruthDup, nIns, nOuts, NULL, 0, pIPerm );
+        nNodes2 = Gia_ManAndNum(pTemp);
+        if ( nNodesBest > nNodes2 )
+        {
+            nNodesBest = nNodes2;
+            memcpy( pIPermBest, pIPerm, sizeof(int)*nIns );
+            rBest = r;
+
+            Gia_ManStopP( &pBest );
+            pBest = pTemp; 
+            pTemp = NULL;
+        }
+        Gia_ManStopP( &pTemp );
+        Abc_TtCopy( pTruthDup, pTruths, (nOuts+1)*nWords, 0 );
+        if ( fVerbose )
+            printf( "Permuted = %5d.  AIG = %5d.\n", nNodesAll, nNodes2 );
+        nNodesAll = 0;
+    }
+    if ( fVerbose )
+        printf( "Best round %3d. Best nodes %5d.  ", rBest, nNodesBest );
+    ABC_FREE( pTruthDup );
+    if ( fVerbose )
+        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    return pBest;
+}
 
 
 /**Function*************************************************************