New technology mapper.

src/base/abci/abc.c

@@ -29522,7 +29522,7 @@ int Abc_CommandAbc9If2( Abc_Frame_t * pAbc, int argc, char ** argv )
     // set defaults
     Mpm_ManSetParsDefault( pPars );
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "KDtmzvh" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "KDtmzvwh" ) ) != EOF )
     {
         switch ( c )
         {
@@ -29565,6 +29565,9 @@ int Abc_CommandAbc9If2( Abc_Frame_t * pAbc, int argc, char ** argv )
         case 'v':
             pPars->fVerbose ^= 1;
             break;
+        case 'w':
+            pPars->fVeryVerbose ^= 1;
+            break;
         case 'h':
         default:
             goto usage;
@@ -29573,7 +29576,8 @@ int Abc_CommandAbc9If2( Abc_Frame_t * pAbc, int argc, char ** argv )
     if ( pPars->pLib == NULL )
         pPars->pLib = Mpm_LibLutSetSimple( nLutSize );
     if ( pPars->fCutMin )
-        pPars->fUseTruth = 1;
+//        pPars->fUseTruth = 1;
+        pPars->fUseDsd = 1;
     // perform mapping
     pNew = Mpm_ManMappingTest( pAbc->pGia, pPars );
     Mpm_LibLutFree( pPars->pLib );
@@ -29590,7 +29594,7 @@ usage:
         sprintf(Buffer, "best possible" );
     else
         sprintf(Buffer, "%d", pPars->DelayTarget );
-    Abc_Print( -2, "usage: &if2 [-KD num] [-tmzvh]\n" );
+    Abc_Print( -2, "usage: &if2 [-KD num] [-tmzvwh]\n" );
     Abc_Print( -2, "\t           performs technology mapping of the network\n" );
     Abc_Print( -2, "\t-K num   : sets the LUT size for the mapping [default = %d]\n", nLutSize );
     Abc_Print( -2, "\t-D num   : sets the delay constraint for the mapping [default = %s]\n", Buffer );
@@ -29598,6 +29602,7 @@ usage:
     Abc_Print( -2, "\t-m       : enables cut minimization by removing vacuous variables [default = %s]\n", pPars->fCutMin? "yes": "no" );
     Abc_Print( -2, "\t-z       : toggles deriving LUTs when mapping into LUT structures [default = %s]\n", pPars->fDeriveLuts? "yes": "no" );
     Abc_Print( -2, "\t-v       : toggles verbose output [default = %s]\n", pPars->fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-w       : toggles very verbose output [default = %s]\n", pPars->fVeryVerbose? "yes": "no" );
     Abc_Print( -2, "\t-h       : prints the command usage\n");
     return 1;
 }

src/map/mpm/mpm.h

@@ -65,6 +65,7 @@ struct Mpm_Par_t_
     int              fCutMin;
     int              fDeriveLuts;
     int              fVerbose;
+    int              fVeryVerbose;
 };
 
 ////////////////////////////////////////////////////////////////////////

src/map/mpm/mpmAbc.c

@@ -183,6 +183,7 @@ void * Mpm_ManFromIfLogic( Mpm_Man_t * pMan )
     Mig_Obj_t * pObj, * pFanin;
     Vec_Int_t * vMapping, * vMapping2, * vPacking = NULL;
     Vec_Int_t * vLeaves, * vLeaves2, * vCover;
+    word uTruth, * pTruth = &uTruth;
     int i, k, Entry, iLitNew;
 //    assert( !pMan->pPars->fDeriveLuts || pMan->pPars->fTruth );
     // start mapping and packing
@@ -211,11 +212,14 @@ void * Mpm_ManFromIfLogic( Mpm_Man_t * pMan )
             pCutBest = Mpm_ObjCutBestP( pMan, pObj );
             Mpm_CutForEachLeaf( pMan->pMig, pCutBest, pFanin, k )
                 Vec_IntPush( vLeaves, Mig_ObjCopy(pFanin) );
-            if ( pMan->pPars->fDeriveLuts && pMan->pPars->fUseTruth )
+            if ( pMan->pPars->fDeriveLuts && (pMan->pPars->fUseTruth || pMan->pPars->fUseDsd) )
             {
                 extern int Gia_ManFromIfLogicNode( Gia_Man_t * pNew, int iObj, Vec_Int_t * vLeaves, Vec_Int_t * vLeavesTemp, 
                     word * pRes, char * pStr, Vec_Int_t * vCover, Vec_Int_t * vMapping, Vec_Int_t * vMapping2, Vec_Int_t * vPacking );
-                word * pTruth = Mpm_CutTruth(pMan, Abc_Lit2Var(pCutBest->iFunc));
+                if ( pMan->pPars->fUseTruth )
+                    pTruth = Mpm_CutTruth(pMan, Abc_Lit2Var(pCutBest->iFunc));
+                else
+                    uTruth = Mpm_CutTruthFromDsd( pMan, pCutBest, Abc_Lit2Var(pCutBest->iFunc) );
 //                Kit_DsdPrintFromTruth( pTruth, Vec_IntSize(vLeaves) );  printf( "\n" );
                 // perform decomposition of the cut
                 iLitNew = Gia_ManFromIfLogicNode( pNew, Mig_ObjId(pObj), vLeaves, vLeaves2, pTruth, NULL, vCover, vMapping, vMapping2, vPacking );

src/map/mpm/mpmCore.c

@@ -54,6 +54,7 @@ void Mpm_ManSetParsDefault( Mpm_Par_t * p )
     p->DelayTarget    =     -1;  // delay target
     p->fDeriveLuts    =      0;  // use truth tables to derive AIG structure
     p->fVerbose       =      0;  // verbose output
+    p->fVeryVerbose   =      0;  // verbose output
 }
 
 /**Function*************************************************************

src/map/mpm/mpmInt.h

@@ -34,6 +34,7 @@
 //#include "misc/tim/tim.h"
 #include "misc/vec/vec.h"
 #include "misc/vec/vecMem.h"
+#include "misc/vec/vecHsh.h"
 #include "misc/mem/mem2.h"
 #include "mpmMig.h"
 #include "mpm.h"
@@ -78,6 +79,14 @@ struct Mpm_Uni_t_
     int              Data[MPM_VAR_MAX];        // padding
 };
 
+typedef struct Mpm_Dsd_t_ Mpm_Dsd_t;
+struct Mpm_Dsd_t_
+{
+    int              nVars;                    // support size
+    word             uTruth;                   // truth table
+    char *           pStr;                     // description 
+};
+
 typedef struct Mpm_Man_t_ Mpm_Man_t;
 struct Mpm_Man_t_
 {
@@ -111,14 +120,19 @@ struct Mpm_Man_t_
     int              nCuts[3];                 // fanin cut counts
     Mpm_Cut_t *      pCuts[3][MPM_CUT_MAX+1];  // fanin cuts
     word             pSigns[3][MPM_CUT_MAX+1]; // fanin cut signatures
-    // functionality
-//    Dsd_Man_t *      pManDsd;
-    void *           pManDsd;
-    int              pPerm[MPM_VAR_MAX]; 
+    // truth tables
     Vec_Mem_t *      vTtMem;                   // truth table memory and hash table
     int              funcCst0;                 // constant 0
     int              funcVar0;                 // variable 0
+    // DSD
+    Mpm_Dsd_t *      pDsd6;                    // NPN class information
+    Hsh_IntMan_t *   pHash;                    // maps DSD functions into NPN classes
+    Vec_Int_t *      vConfgRes;                // configurations
+    Vec_Wrd_t *      vPerm6;                   // permutations of DSD classes
+    char             Perm6[720][6];            // permutations
+    Vec_Int_t *      vMap2Perm;                // maps number into its permutation
     unsigned         uPermMask[3];
+    unsigned         uComplMask[3];
     // mapping attributes
     Vec_Int_t        vCutBests;                // cut best
     Vec_Int_t        vCutLists;                // cut list
@@ -129,8 +143,11 @@ struct Mpm_Man_t_
     Vec_Int_t        vTimes;                   // arrival time
     Vec_Int_t        vAreas;                   // area
     Vec_Int_t        vEdges;                   // edge
+    int              nCountDsd[600];
+    int              nNonDsd;
     // statistics
     int              nCutsMerged;
+    int              nCutsMergedAll;
     int              nSmallSupp;
     abctime          timeFanin;
     abctime          timeDerive;
@@ -212,15 +229,22 @@ extern void                  Mpm_ManStop( Mpm_Man_t * p );
 extern void                  Mpm_ManPrintStatsInit( Mpm_Man_t * p );
 extern void                  Mpm_ManPrintStats( Mpm_Man_t * p );
 /*=== mpmDsd.c ===========================================================*/
+extern void                  Mpm_ManPrintDsdStats( Mpm_Man_t * p );
+extern void                  Mpm_ManPrintPerm( unsigned s );
+extern void                  Mpm_ManPrecomputePerms( Mpm_Man_t * p );
+extern word                  Mpm_CutTruthFromDsd( Mpm_Man_t * pMan, Mpm_Cut_t * pCut, int iDsdLit );
+extern int                   Mpm_CutComputeDsd6( Mpm_Man_t * p, Mpm_Cut_t * pCut, Mpm_Cut_t * pCut0, Mpm_Cut_t * pCut1, Mpm_Cut_t * pCutC, int fCompl0, int fCompl1, int fComplC, int Type );
 /*=== mpmLib.c ===========================================================*/
 extern Mpm_LibLut_t *        Mpm_LibLutSetSimple( int nLutSize );
 extern void                  Mpm_LibLutFree( Mpm_LibLut_t * pLib );
 /*=== mpmMap.c ===========================================================*/
+extern void                  Mpm_CutPrint( Mpm_Cut_t * pCut );
 extern void                  Mpm_ManPrepare( Mpm_Man_t * p );
 extern void                  Mpm_ManPerform( Mpm_Man_t * p );
 /*=== mpmTruth.c ===========================================================*/
 extern int                   Mpm_CutComputeTruth6( Mpm_Man_t * p, Mpm_Cut_t * pCut, Mpm_Cut_t * pCut0, Mpm_Cut_t * pCut1, Mpm_Cut_t * pCutC, int fCompl0, int fCompl1, int fComplC, int Type );
 
+extern void                  Kit_DsdPrintFromTruth( unsigned * pTruth, int nVars );
 
 ABC_NAMESPACE_HEADER_END
 

src/map/mpm/mpmMan.c

@@ -57,7 +57,6 @@ Mpm_Man_t * Mpm_ManStart( Mig_Man_t * pMig, Mpm_Par_t * pPars )
     p->nLutSize  = pPars->pLib->LutMax;
     p->nTruWords = pPars->fUseTruth ? Abc_Truth6WordNum(p->nLutSize) : 0;
     p->nNumCuts  = pPars->nNumCuts;
-    p->timeTotal = Abc_Clock();
     // cuts
     assert( Mpm_CutWordNum(32) < 32 ); // using 5 bits for word count
     p->pManCuts  = Mmr_StepStart( 13, Abc_Base2Log(Mpm_CutWordNum(p->nLutSize) + 1) );
@@ -79,10 +78,9 @@ Mpm_Man_t * Mpm_ManStart( Mig_Man_t * pMig, Mpm_Par_t * pPars )
     Vec_IntFill( &p->vAreas, Mig_ManObjNum(pMig), 0 );
     Vec_IntFill( &p->vEdges, Mig_ManObjNum(pMig), 0 );
     // start DSD manager
-    p->pManDsd   = NULL;
-    pMig->pMan   = p;
+    assert( !p->pPars->fUseTruth || !p->pPars->fUseDsd );
     if ( p->pPars->fUseTruth )
-    {
+    { 
         word Truth = 0;
         p->vTtMem = Vec_MemAlloc( p->nTruWords, 12 ); // 32 KB/page for 6-var functions
         Vec_MemHashAlloc( p->vTtMem, 10000 );
@@ -90,8 +88,14 @@ Mpm_Man_t * Mpm_ManStart( Mig_Man_t * pMig, Mpm_Par_t * pPars )
         Truth = ABC_CONST(0xAAAAAAAAAAAAAAAA);
         p->funcVar0 = Vec_MemHashInsert( p->vTtMem, &Truth );
     }
-    else 
+    else if ( p->pPars->fUseDsd )
+    {
+        Mpm_ManPrecomputePerms( p );
         p->funcVar0 = 1;
+    }
+    // finish
+    p->timeTotal = Abc_Clock();
+    pMig->pMan = p;
     return p;
 }
 
@@ -108,11 +112,21 @@ Mpm_Man_t * Mpm_ManStart( Mig_Man_t * pMig, Mpm_Par_t * pPars )
 ***********************************************************************/
 void Mpm_ManStop( Mpm_Man_t * p )
 {
+    if ( p->pPars->fUseDsd )
+        Mpm_ManPrintDsdStats( p );
     if ( p->vTtMem ) 
     {
         Vec_MemHashFree( p->vTtMem );
         Vec_MemFree( p->vTtMem );
     }
+    if ( p->pHash )
+    {
+        Vec_WrdFree( p->vPerm6 );
+        Vec_IntFree( p->vMap2Perm );
+        Vec_IntFree( p->vConfgRes );
+        Vec_IntFree( p->pHash->vData );
+        Hsh_IntManStop( p->pHash );
+    }
     Vec_PtrFree( p->vTemp );
     Mmr_StepStop( p->pManCuts );
     ABC_FREE( p->vObjPresUsed.pArray );
@@ -145,11 +159,11 @@ void Mpm_ManStop( Mpm_Man_t * p )
 ***********************************************************************/
 void Mpm_ManPrintStatsInit( Mpm_Man_t * p )
 {
-    printf( "K = %d.  C = %d.  Cands = %d. XOR = %d. MUX = %d. Choices = %d.   CutMin = %d. Truth = %d.\n", 
+    printf( "K = %d.  C = %d.  Cand = %d. XOR = %d. MUX = %d. Choice = %d.  CutMin = %d. Truth = %d. DSD = %d.\n", 
         p->nLutSize, p->nNumCuts, 
         Mig_ManCiNum(p->pMig) + Mig_ManNodeNum(p->pMig), 
         Mig_ManXorNum(p->pMig), Mig_ManMuxNum(p->pMig), 0, 
-        p->pPars->fCutMin, p->pPars->fUseTruth );
+        p->pPars->fCutMin, p->pPars->fUseTruth, p->pPars->fUseDsd );
 }
 void Mpm_ManPrintStats( Mpm_Man_t * p )
 {

src/map/mpm/mpmMap.c

@@ -31,63 +31,6 @@ ABC_NAMESPACE_IMPL_START
 ///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
-/*
-        // check special cases
-        if ( fUseFunc )
-        {
-            pCut0 = p->pCuts[0][0];  pCut1 = p->pCuts[1][0];
-            if ( pCut0->iFunc < 2 || pCut1->iFunc < 2 )
-            {
-                assert( Mig_ObjIsAnd(pObj) );
-                if (  Abc_LitNotCond(pCut0->iFunc, Mig_ObjFaninC0(pObj)) == 0 ||
-                      Abc_LitNotCond(pCut1->iFunc, Mig_ObjFaninC1(pObj)) == 0 ) // set the resulting cut to 0
-                    Mig_ManObj(p, pObj)->hCutList = Mpm_CutCreateZero( p, pObj );
-                else if ( Abc_LitNotCond(pCut0->iFunc, Mig_ObjFaninC0(pObj)) == 1 ) // set the resulting set to be that of Fanin1
-                    Mig_ManObj(p, pObj)->hCutList = Mpm_CutCopySet( p, Mig_ObjFanin1(pObj), 0 );
-                else if ( Abc_LitNotCond(pCut1->iFunc, Mig_ObjFaninC1(pObj)) == 1 ) // set the resulting set to be that of Fanin0
-                    Mig_ManObj(p, pObj)->hCutList = Mpm_CutCopySet( p, Mig_ObjFanin0(pObj), 0 );
-                else assert( 0 );
-                goto finish;
-            }
-        }
-            // compute cut function
-            if ( fUseFunc )
-            {
-                extern int Mpm_FuncCompute( void * p, int iDsd0, int iDsd1, Vec_Str_t * vShared, int * pPerm, int * pnLeaves );
-                int nLeavesOld = p->pCutTemp->nLeaves;
-                int nLeaves    = p->pCutTemp->nLeaves;
-                iDsd0 = Abc_LitNotCond( pCut0->iFunc, Mig_ObjFaninC0(pObj) );
-                iDsd1 = Abc_LitNotCond( pCut1->iFunc, Mig_ObjFaninC1(pObj) );
-                if ( iDsd0 > iDsd1 )
-                {
-                    ABC_SWAP( int, iDsd0, iDsd1 );
-                    ABC_SWAP( Mpm_Cut_t *, pCut0, pCut1 );
-                }
-                // compute functionality and filter cuts dominated by support-reduced cuts
-                p->pCutTemp->iFunc = Mpm_FuncCompute( p->pManDsd, iDsd0, iDsd1, &p->vObjShared, p->pPerm, &nLeaves );
-                Mpm_ObjUpdateCut( p->pCutTemp, p->pPerm, nLeaves );
-                // consider filtering based on functionality
-                if ( nLeaves == 0 ) // derived const cut
-                {
-                    Mig_ManObj(p, pObj)->hCutList = Mpm_CutCreateZero( p, pObj );
-                    goto finish;
-                }
-                if ( nLeaves == 1 ) // derived unit cut
-                {
-                    pFanin = Mig_ManObj( p->pMig, Abc_Lit2Var(p->pCutTemp->pLeaves[0]) );
-                    Mig_ManObj(p, pObj)->hCutList = Mpm_CutCopySet( p, pFanin, Abc_LitIsCompl(p->pCutTemp->pLeaves[0]) );
-                    goto finish;
-                }
-                if ( nLeaves < nLeavesOld ) // reduced support of the cut
-                {
-                    ArrTime = Mpm_CutGetArrTime( p, p->pCutTemp );
-                    if ( ArrTime > pMapObj->mRequired )
-                        continue;
-                }
-            }
-*/
-
-
 /**Function*************************************************************
 
   Synopsis    [Cut manipulation.]
@@ -170,7 +113,7 @@ static inline void Mpm_CutDeref( Mpm_Man_t * p, int * pLeaves, int nLeaves )
         Mig_ManObj( p->pMig, Abc_Lit2Var(pLeaves[i]) )->nMapRefs--;
 }
 */
-static inline void Mpm_CutPrint( Mpm_Cut_t * pCut )  
+void Mpm_CutPrint( Mpm_Cut_t * pCut )  
 { 
     int i;
     printf( "%d : { ", pCut->nLeaves );
@@ -509,6 +452,14 @@ static inline int Mpm_ObjDeriveCut( Mpm_Man_t * p, Mpm_Cut_t ** pCuts, Mpm_Cut_t
         p->pObjPres[p->vObjPresUsed.pArray[i]] = (unsigned char)0xFF;
     Vec_IntClear(&p->vObjPresUsed);   
     Vec_StrClear(&p->vObjShared);   
+/*
+    if ( pCuts[0]->nLeaves == 5 && pCuts[1]->nLeaves == 5 )
+    {
+        int s = 0;
+        Mpm_CutPrint( pCuts[0] );
+        Mpm_CutPrint( pCuts[1] );
+    }
+*/
     // check present objects
 //    for ( i = 0; i < Mig_ManObjNum(p->pMig); i++ )
 //        assert( p->pObjPres[i] == (unsigned char)0xFF );
@@ -524,23 +475,32 @@ static inline int Mpm_ObjDeriveCut( Mpm_Man_t * p, Mpm_Cut_t ** pCuts, Mpm_Cut_t
     // remaining cuts
     for ( c = 1; pCuts[c] && c < 3; c++ )
     {
+        p->uPermMask[c] = 0x3FFFF; // 18 bits
+        p->uComplMask[c] = 0;     
         for ( i = 0; i < (int)pCuts[c]->nLeaves; i++ )
         {
             iObj = Abc_Lit2Var(pCuts[c]->pLeaves[i]);
-            if ( p->pObjPres[iObj] != (unsigned char)0xFF )
-                continue;
-            if ( (int)pCut->nLeaves == p->nLutSize )
-                return 0;
-            Vec_IntPush( &p->vObjPresUsed, iObj );
-            p->pObjPres[iObj] = pCut->nLeaves;        
-            pCut->pLeaves[pCut->nLeaves++] = pCuts[c]->pLeaves[i];
+            if ( p->pObjPres[iObj] == (unsigned char)0xFF )
+            {
+                if ( (int)pCut->nLeaves == p->nLutSize )
+                    return 0;
+                Vec_IntPush( &p->vObjPresUsed, iObj );
+                p->pObjPres[iObj] = pCut->nLeaves;        
+                pCut->pLeaves[pCut->nLeaves++] = pCuts[c]->pLeaves[i];
+            }
+            p->uPermMask[c] ^= (((i & 7) ^ 7) << (3*p->pObjPres[iObj]));
+            assert( Abc_Lit2Var(pCuts[c]->pLeaves[i]) == Abc_Lit2Var(pCut->pLeaves[p->pObjPres[iObj]]) );
+            if ( pCuts[c]->pLeaves[i] != pCut->pLeaves[p->pObjPres[iObj]] )
+                p->uComplMask[c] |= (1 << p->pObjPres[iObj]);
         }
+//        Mpm_ManPrintPerm( p->uPermMask[c] ); printf( "\n" );
     }
     pCut->hNext    = 0;
     pCut->iFunc    = 0;  pCut->iFunc = ~pCut->iFunc;
     pCut->fUseless = 0;
     pCut->fCompl   = 0;
     p->nCutsMerged++;
+    p->nCutsMergedAll++;
     if ( p->pPars->fUseTruth )
         Vec_IntSelectSort( pCut->pLeaves, pCut->nLeaves );
     return 1;
@@ -566,6 +526,11 @@ p->timeMerge += clock() - clk;
     // derive truth table
     if ( p->pPars->fUseTruth )
         Mpm_CutComputeTruth6( p, pCut, pCuts[0], pCuts[1], pCuts[2], Mig_ObjFaninC0(pObj), Mig_ObjFaninC1(pObj), Mig_ObjFaninC2(pObj), Mig_ObjNodeType(pObj) ); 
+    else if ( p->pPars->fUseDsd )
+    {
+        if ( !Mpm_CutComputeDsd6( p, pCut, pCuts[0], pCuts[1], pCuts[2], Mig_ObjFaninC0(pObj), Mig_ObjFaninC1(pObj), Mig_ObjFaninC2(pObj), Mig_ObjNodeType(pObj) ) )
+            return 1;
+    }
 
 #ifdef MIG_RUNTIME
 p->timeMerge += clock() - clk;
@@ -587,8 +552,21 @@ clk = Abc_Clock();
 p->timeStore += Abc_Clock() - clk;
 #endif
 
-    return 1;
     // return 0 if const or buffer cut is derived - reset all cuts to contain only one
+//    if ( pCut->nLeaves < 2 && p->nCutStore == 1 )
+//        return 0;
+/*
+    if ( pCut->nLeaves < 2 )
+    {
+        int i;
+        assert( p->nCutStore >= 1 );
+        for ( i = 1; i < p->nCutStore; i++ )
+            Vec_PtrPush( &p->vFreeUnits, p->pCutStore[i] );
+        p->nCutStore = 1;
+        return 0;
+    }
+*/
+    return 1;
 }
 int Mpm_ManDeriveCuts( Mpm_Man_t * p, Mig_Obj_t * pObj )
 {

src/map/mpm/mpmPre.c

@@ -172,19 +172,32 @@ void Ifd_ObjPrint( Ifd_Man_t * p, int iLit )
 {
     int Counter = 0;
     if ( iLit == 0 )
-        { printf( "0\n" ); return; }
+        { printf( "0" ); return; }
     if ( iLit == 1 )
-        { printf( "1\n" ); return; }
+        { printf( "1" ); return; }
     Ifd_ObjPrint_rec( p, iLit, &Counter, 1 );
-    printf( "\n" );
 }
-void Ifd_ManPrint( Ifd_Man_t * p )
+void Ifd_ManPrint2( Ifd_Man_t * p )
 {
     int i;
     for ( i = 0; i < p->nObjs; i++ )
     {
         printf( "%4d : ", i );
         Ifd_ObjPrint( p, Abc_Var2Lit( i, 0 ) );
+        printf( "\n" );
+    }
+}
+void Ifd_ManPrint( Ifd_Man_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nObjs; i++ )
+    {
+        word Fun = Vec_WrdEntry( p->vTruths, i );
+        printf( "    { %d, ABC_CONST(", Extra_TruthSupportSize((unsigned *)&Fun, 6) );
+        Extra_PrintHex( stdout, (unsigned *)&Fun, 6 ); 
+        printf( "), \"" );
+        Ifd_ObjPrint( p, Abc_Var2Lit( i, 0 ) );
+        printf( "\" },   // %4d \n", i );
     }
 }
 
@@ -532,6 +545,7 @@ void Ifd_ManDsdTest2()
     int iLit = Ifd_ManFindDsd( pMan, p );
     Ifd_ObjPrint( pMan, iLit );
     Ifd_ManStop( pMan );
+    printf( "\n" );
 }
 
 /**Function*************************************************************
@@ -600,8 +614,8 @@ Vec_Wrd_t * Ifd_ManDsdTruths( int nVars )
         // bookmark
         Vec_IntPush( pMan->vMarks, pMan->nObjs );
     }
-//    Ifd_ManPrint( pMan );
     Ifd_ManTruthAll( pMan );
+//    Ifd_ManPrint( pMan );
     vTruths = pMan->vTruths; pMan->vTruths = NULL;
     Ifd_ManStop( pMan );
     return vTruths;
@@ -753,25 +767,26 @@ Vec_Wrd_t * Extra_Truth6AllConfigs( word t, int * pComp, int * pPerm, int nVars
     int nPerms = Extra_Factorial( nVars );
     int nSwaps = (1 << nVars);
     Vec_Wrd_t * vTruths = Vec_WrdStart( nPerms * nSwaps );
-    word tCur, tTemp1, tTemp2;
-    int i, p, c;
-    for ( i = 1; i < 2; i++ )
+    word tCur = t, tTemp1, tTemp2;
+    int p, c, Config;
+
+    tTemp1 = tCur;
+    for ( p = 0; p < nPerms; p++ )
     {
-        tCur = i ? ~t : t;
-        tTemp1 = tCur;
-        for ( p = 0; p < nPerms; p++ )
+        tCur = Extra_Truth6SwapAdjacent( tCur, pPerm[p] );
+        Config = 0;
+        tTemp2 = tCur;
+        for ( c = 0; c < nSwaps; c++ )
         {
-            tTemp2 = tCur;
-            for ( c = 0; c < nSwaps; c++ )
-            {
-                Vec_WrdWriteEntry( vTruths, (p << (nVars))|c, tCur );
-                tCur = Extra_Truth6ChangePhase( tCur, pComp[c] );
-            }
-            assert( tTemp2 == tCur );
-            tCur = Extra_Truth6SwapAdjacent( tCur, pPerm[p] );
+            Vec_WrdWriteEntry( vTruths, (p << nVars)|Config, tCur );
+            tCur = Extra_Truth6ChangePhase( tCur, pComp[c] );
+            Config ^= (1 << pComp[c]);
         }
-        assert( tTemp1 == tCur );
+        assert( Config == 0 );
+        assert( tTemp2 == tCur );
     }
+    assert( tTemp1 == tCur );
+
     if ( t )
     {
         int i;
@@ -793,7 +808,7 @@ Vec_Wrd_t * Extra_Truth6AllConfigs( word t, int * pComp, int * pPerm, int nVars
   SeeAlso     []
 
 ***********************************************************************/
-int Ifd_ManDsdTest33() 
+int Ifd_ManDsdTest() 
 {
     int nVars = 6;
     FILE * pFile;
@@ -801,6 +816,7 @@ int Ifd_ManDsdTest33()
     Vec_Wrd_t * vTruths = Ifd_ManDsdTruths( nVars );
     Vec_Wrd_t * vVariants;
     Vec_Int_t * vUniques;
+    Vec_Int_t * vCompls;
     Vec_Wrd_t * vTruthRes = Vec_WrdAlloc( 4000000 );
     Vec_Int_t * vConfgRes = Vec_IntAlloc( 4000000 );
     int * pComp, * pPerm;
@@ -808,19 +824,29 @@ int Ifd_ManDsdTest33()
     int i, k, Uniq, Runner, Counter = 0;
     assert( nVars >= 3 && nVars <= 6 );
     assert( Vec_WrdSize(vTruths) < (1<<10) );
+    vCompls = Vec_IntAlloc( 720 * 64 );
     pComp = Extra_GreyCodeSchedule( nVars );
     pPerm = Extra_PermSchedule( nVars );
     Vec_WrdForEachEntry( vTruths, Truth, i )
     {
         vVariants = Extra_Truth6AllConfigs( Truth, pComp, pPerm, nVars );
+        // save compl bits
+        Vec_IntClear( vCompls );
+        Vec_WrdForEachEntry( vVariants, Variant, k )
+        {
+            Vec_IntPush( vCompls, (int)(Variant & 1) );
+            Vec_WrdWriteEntry( vVariants, k, Variant & 1 ? ~Variant : Variant );
+        }
+        // uniqify
         vUniques = Hsh_WrdManHashArray( vVariants, 1 );
         Runner = 0;
         Vec_IntForEachEntry( vUniques, Uniq, k )
             if ( Runner == Uniq )
             {
                 Variant = Vec_WrdEntry(vVariants, k);
+                assert( (Variant & 1) == 0 );
                 Vec_WrdPush( vTruthRes, Variant );
-                Vec_IntPush( vConfgRes, (Extra_TruthSupportSize((unsigned *)&Variant, 6)<<26)|(i << 16)|k );
+                Vec_IntPush( vConfgRes, (i << 17)|(Vec_IntEntry(vCompls, k) << 16)|k );
                 Runner++;
             }
         Vec_IntUniqify( vUniques );
@@ -829,7 +855,8 @@ int Ifd_ManDsdTest33()
 //printf( "%5d : ", i ); Kit_DsdPrintFromTruth( &Truth, nVars ), printf( "  " ), Vec_IntPrint( vUniques ), printf( "\n" );
         Vec_IntFree( vUniques );
         Vec_WrdFree( vVariants );
-    }
+    } 
+    Vec_IntFree( vCompls );
     Vec_WrdFree( vTruths );
     ABC_FREE( pPerm );
     ABC_FREE( pComp );
@@ -847,12 +874,12 @@ int Ifd_ManDsdTest33()
     return 1;
 }
 
-int Ifd_ManDsdTest() 
+int Ifd_ManDsdTest33() 
 {
     abctime clk = Abc_Clock();
     FILE * pFile;
     char * pFileName = "dsdfuncs6.dat";
-    int RetValue, size = Extra_FileSize( pFileName ) / 12;  // 3504275
+    int RetValue, size = Extra_FileSize( pFileName ) / 12;  // 2866420
     Vec_Wrd_t * vTruthRes = Vec_WrdAlloc( size + 1 );
     Vec_Int_t * vConfgRes = Vec_IntAlloc( size );
     Hsh_IntMan_t * pHash;

src/map/mpm/mpmTruth.c

@@ -94,6 +94,7 @@ static inline word Mpm_TruthStretch6( word Truth, Mpm_Cut_t * pCut, Mpm_Cut_t *
     }
     return Truth;
 }
+//#define MPM_TRY_NEW
 int Mpm_CutComputeTruth6( Mpm_Man_t * p, Mpm_Cut_t * pCut, Mpm_Cut_t * pCut0, Mpm_Cut_t * pCut1, Mpm_Cut_t * pCutC, int fCompl0, int fCompl1, int fComplC, int Type )
 {
     word * pTruth0 = Mpm_CutTruth( p, Abc_Lit2Var(pCut0->iFunc) );
@@ -129,9 +130,10 @@ int Mpm_CutComputeTruth6( Mpm_Man_t * p, Mpm_Cut_t * pCut, Mpm_Cut_t * pCut0, Mp
 
 #ifdef MPM_TRY_NEW
     {
+        extern unsigned      Abc_TtCanonicize( word * pTruth, int nVars, char * pCanonPerm );
         word tCopy = t;
         char pCanonPerm[16];
-        Abc_TtCanonicize( &tCopy, pCut->nLimit, pCanonPerm );
+        Abc_TtCanonicize( &tCopy, p->nLutSize, pCanonPerm );
     }
 #endif
 

src/misc/vec/vecHsh.h

@@ -210,9 +210,18 @@ static inline Vec_Int_t * Hsh_WrdManHashArray( Vec_Wrd_t * vDataW, int nSize )
 static inline Hsh_IntMan_t * Hsh_WrdManHashArrayStart( Vec_Wrd_t * vDataW, int nSize )
 {
     Hsh_IntMan_t * p;
-    Vec_Int_t Data = { 2*Vec_WrdCap(vDataW), 2*Vec_WrdSize(vDataW), (int *)Vec_WrdArray(vDataW) };
-    Vec_Int_t * vData = &Data;
-    int i, nEntries = Vec_IntSize(vData) / (2*nSize);
+    int i, nEntries = Vec_WrdSize(vDataW) / nSize;
+    Vec_Int_t * vData = Vec_IntAlloc( 2*Vec_WrdSize(vDataW) );
+    memcpy( Vec_IntArray(vData), Vec_WrdArray(vDataW), sizeof(word)*Vec_WrdSize(vDataW) );
+    vData->nSize = 2*Vec_WrdSize(vDataW);
+/*
+    for ( i = 0; i < 30; i++ )
+    {
+        extern void Extra_PrintHex( FILE * pFile, unsigned * pTruth, int nVars );
+        Extra_PrintHex( stdout, (unsigned *) Vec_WrdEntryP(vDataW, i), 6 );  printf( "  " );
+        Kit_DsdPrintFromTruth( (unsigned *) Vec_WrdEntryP(vDataW, i), 6 );   printf( "\n" );
+    }
+*/
     assert( Vec_IntSize(vData) % (2*nSize) == 0 );
     p = Hsh_IntManStart( vData, (2*nSize), nEntries );
     for ( i = 0; i < nEntries; i++ )