Version abc80420_2

Makefile

@@ -20,7 +20,7 @@ MODULES := src/base/abc src/base/abci src/base/cmd \
 	src/aig/mem src/aig/dar src/aig/fra src/aig/cnf \
 	src/aig/csw src/aig/ioa src/aig/aig src/aig/kit \
 	src/aig/bdc src/aig/bar src/aig/ntl src/aig/nwk src/aig/mfx \
-	src/aig/tim
+	src/aig/tim src/aig/saig
 
 default: $(PROG)
 

abc.dsp

@@ -3248,6 +3248,10 @@ SOURCE=.\src\aig\saig\saig.h
 
 SOURCE=.\src\aig\saig\saigPhase.c
 # End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\saig\saigRetMin.c
+# End Source File
 # End Group
 # End Group
 # End Group

src/aig/ntl/ntl.h

@@ -235,7 +235,7 @@ extern void            Ntl_ManPrepareCec( char * pFileName1, char * pFileName2,
 extern Aig_Man_t *     Ntl_ManPrepareSec( char * pFileName1, char * pFileName2 );
 /*=== ntlExtract.c ==========================================================*/
 extern Aig_Man_t *     Ntl_ManExtract( Ntl_Man_t * p );
-extern Aig_Man_t *     Ntl_ManCollapse( Ntl_Man_t * p );
+extern Aig_Man_t *     Ntl_ManCollapse( Ntl_Man_t * p, int fSeq );
 extern Aig_Man_t *     Ntl_ManCollapseForCec( Ntl_Man_t * p );
 extern Aig_Man_t *     Ntl_ManCollapseForSec( Ntl_Man_t * p1, Ntl_Man_t * p2 );
 /*=== ntlInsert.c ==========================================================*/
@@ -247,12 +247,13 @@ extern int             Ntl_ManCheck( Ntl_Man_t * pMan );
 extern int             Ntl_ModelCheck( Ntl_Mod_t * pModel );
 extern void            Ntl_ModelFixNonDrivenNets( Ntl_Mod_t * pModel );
 /*=== ntlMan.c ============================================================*/
-extern Ntl_Man_t *     Ntl_ManAlloc( char * pFileName );
+extern Ntl_Man_t *     Ntl_ManAlloc();
 extern void            Ntl_ManCleanup( Ntl_Man_t * p );
 extern Ntl_Man_t *     Ntl_ManStartFrom( Ntl_Man_t * p );
 extern Ntl_Man_t *     Ntl_ManDup( Ntl_Man_t * p );
 extern void            Ntl_ManFree( Ntl_Man_t * p );
 extern int             Ntl_ManIsComb( Ntl_Man_t * p );
+extern int             Ntl_ManLatchNum( Ntl_Man_t * p );
 extern Ntl_Mod_t *     Ntl_ManFindModel( Ntl_Man_t * p, char * pName );
 extern void            Ntl_ManPrintStats( Ntl_Man_t * p );
 extern Tim_Man_t *     Ntl_ManReadTimeMan( Ntl_Man_t * p );
@@ -292,6 +293,7 @@ extern Tim_Man_t *     Ntl_ManCreateTiming( Ntl_Man_t * p );
 extern Ntl_Man_t *     Ioa_ReadBlif( char * pFileName, int fCheck );
 /*=== ntlWriteBlif.c ==========================================================*/
 extern void            Ioa_WriteBlif( Ntl_Man_t * p, char * pFileName );
+extern void            Ioa_WriteBlifLogic( Nwk_Man_t * pNtk, Ntl_Man_t * p, char * pFileName );
 /*=== ntlUtil.c ==========================================================*/
 extern int             Ntl_ModelCountLut1( Ntl_Mod_t * pRoot );
 extern int             Ntl_ManCountSimpleCoDrivers( Ntl_Man_t * p );

src/aig/ntl/ntlEc.c

@@ -238,7 +238,7 @@ void Ntl_ManPrepareCec( char * pFileName1, char * pFileName2, Aig_Man_t ** ppMan
     // derive AIGs
     *ppMan1 = Ntl_ManCollapseForCec( pMan1 );
     *ppMan2 = Ntl_ManCollapseForCec( pMan2 );
-    // cleanup
+    // cleanup 
     Ntl_ManFree( pMan1 );
     Ntl_ManFree( pMan2 );
 }

src/aig/ntl/ntlExtract.c

@@ -404,7 +404,7 @@ int Ntl_ManCollapse_rec( Ntl_Man_t * p, Ntl_Net_t * pNet )
   SeeAlso     []
 
 ***********************************************************************/
-Aig_Man_t * Ntl_ManCollapse( Ntl_Man_t * p )
+Aig_Man_t * Ntl_ManCollapse( Ntl_Man_t * p, int fSeq )
 {
     Aig_Man_t * pAig;
     Ntl_Mod_t * pRoot;
@@ -443,6 +443,8 @@ Aig_Man_t * Ntl_ManCollapse( Ntl_Man_t * p )
         assert( Ntl_ObjFanoutNum(pObj) == 1 );
         pNet = Ntl_ObjFanout0(pObj);
         pNet->pCopy = Aig_ObjCreatePi( p->pAig );
+        if ( fSeq && (pObj->LatchId & 3) == 1 )
+            pNet->pCopy = Aig_Not(pNet->pCopy);
         if ( pNet->nVisits )
         {
             printf( "Ntl_ManCollapse(): Latch output is duplicated or defined as a primary input.\n" );
@@ -470,7 +472,10 @@ Aig_Man_t * Ntl_ManCollapse( Ntl_Man_t * p )
             printf( "Ntl_ManCollapse(): Error: Combinational loop is detected.\n" );
             return 0;
         }
-        Aig_ObjCreatePo( p->pAig, pNet->pCopy );
+        if ( fSeq && (pObj->LatchId & 3) == 1 )
+            Aig_ObjCreatePo( p->pAig, Aig_Not(pNet->pCopy) );
+        else
+            Aig_ObjCreatePo( p->pAig, pNet->pCopy );
     }
     // cleanup the AIG
     Aig_ManCleanup( p->pAig );

src/aig/ntl/ntlFraig.c

@@ -181,6 +181,35 @@ void Ntl_ManReduce( Ntl_Man_t * p, Aig_Man_t * pAig )
 
 /**Function*************************************************************
 
+  Synopsis    [Resets complemented attributes of the collapsed AIG.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ntl_ManResetComplemented( Ntl_Man_t * p, Aig_Man_t * pAigCol )
+{
+    Ntl_Mod_t * pRoot;
+    Ntl_Obj_t * pObj;
+    Aig_Obj_t * pObjCol;
+    int i;
+    pRoot = Ntl_ManRootModel(p);
+    Ntl_ModelForEachLatch( pRoot, pObj, i )
+    {
+        if ( (pObj->LatchId & 3) == 1 )
+        {
+            pObjCol = Ntl_ObjFanout0(pObj)->pCopy;
+            assert( pObjCol->fPhase == 0 );
+            pObjCol->fPhase = 1;
+        }
+    }
+}
+ 
+/**Function*************************************************************
+
   Synopsis    [Finalizes the transformation.]
 
   Description []
@@ -242,14 +271,14 @@ Ntl_Man_t * Ntl_ManFraig( Ntl_Man_t * p, int nPartSize, int nConfLimit, int nLev
     // collapse the AIG
     pAig = Ntl_ManExtract( p );
     pNew = Ntl_ManInsertAig( p, pAig );
-    pAigCol = Ntl_ManCollapse( pNew );
+    pAigCol = Ntl_ManCollapse( pNew, 0 );
 
     // perform fraiging for the given design
     nPartSize = nPartSize? nPartSize : Aig_ManPoNum(pAigCol);
     pTemp = Aig_ManFraigPartitioned( pAigCol, nPartSize, nConfLimit, nLevelMax, fVerbose );
     Aig_ManStop( pTemp );
 
-    // finalize the transformatoin
+    // finalize the transformation
     pNew = Ntl_ManFinalize( pAux = pNew, pAig, pAigCol, fVerbose );
     Ntl_ManFree( pAux );
     Aig_ManStop( pAig );
@@ -273,20 +302,17 @@ Ntl_Man_t * Ntl_ManScl( Ntl_Man_t * p, int fLatchConst, int fLatchEqual, int fVe
     Ntl_Man_t * pNew, * pAux;
     Aig_Man_t * pAig, * pAigCol, * pTemp;
 
-    // transform the design
-    Ntl_ManTransformInitValues( p );
-
     // collapse the AIG
     pAig = Ntl_ManExtract( p );
     pNew = Ntl_ManInsertAig( p, pAig );
-    pAigCol = Ntl_ManCollapse( pNew );
+    pAigCol = Ntl_ManCollapse( pNew, 1 );
 
     // perform SCL for the given design
     pAigCol->nRegs = Ntl_ModelLatchNum(Ntl_ManRootModel(p));
     pTemp = Aig_ManScl( pAigCol, fLatchConst, fLatchEqual, fVerbose );
     Aig_ManStop( pTemp );
 
-    // finalize the transformatoin
+    // finalize the transformation
     pNew = Ntl_ManFinalize( pAux = pNew, pAig, pAigCol, fVerbose );
     Ntl_ManFree( pAux );
     Aig_ManStop( pAig );
@@ -310,20 +336,17 @@ Ntl_Man_t * Ntl_ManLcorr( Ntl_Man_t * p, int nConfMax, int fVerbose )
     Ntl_Man_t * pNew, * pAux;
     Aig_Man_t * pAig, * pAigCol, * pTemp;
 
-    // transform the design
-    Ntl_ManTransformInitValues( p );
-
     // collapse the AIG
     pAig = Ntl_ManExtract( p );
     pNew = Ntl_ManInsertAig( p, pAig );
-    pAigCol = Ntl_ManCollapse( pNew );
+    pAigCol = Ntl_ManCollapse( pNew, 1 );
 
     // perform SCL for the given design
     pAigCol->nRegs = Ntl_ModelLatchNum(Ntl_ManRootModel(p));
     pTemp = Fra_FraigLatchCorrespondence( pAigCol, 0, nConfMax, 0, fVerbose, NULL );
     Aig_ManStop( pTemp );
 
-    // finalize the transformatoin
+    // finalize the transformation
     pNew = Ntl_ManFinalize( pAux = pNew, pAig, pAigCol, fVerbose );
     Ntl_ManFree( pAux );
     Aig_ManStop( pAig );
@@ -347,20 +370,17 @@ Ntl_Man_t * Ntl_ManSsw( Ntl_Man_t * p, Fra_Ssw_t * pPars )
     Ntl_Man_t * pNew, * pAux;
     Aig_Man_t * pAig, * pAigCol, * pTemp;
 
-    // transform the design
-    Ntl_ManTransformInitValues( p );
-
     // collapse the AIG
     pAig = Ntl_ManExtract( p );
     pNew = Ntl_ManInsertAig( p, pAig );
-    pAigCol = Ntl_ManCollapse( pNew );
+    pAigCol = Ntl_ManCollapse( pNew, 1 );
 
     // perform SCL for the given design
     pAigCol->nRegs = Ntl_ModelLatchNum(Ntl_ManRootModel(p));
     pTemp = Fra_FraigInduction( pAigCol, pPars );
     Aig_ManStop( pTemp );
 
-    // finalize the transformatoin
+    // finalize the transformation
     pNew = Ntl_ManFinalize( pAux = pNew, pAig, pAigCol, pPars->fVerbose );
     Ntl_ManFree( pAux );
     Aig_ManStop( pAig );
@@ -459,6 +479,63 @@ void Ntl_ManAttachWhiteBoxes( Ntl_Man_t * p, Aig_Man_t * pAigCol, Aig_Man_t * pA
 
 /**Function*************************************************************
 
+  Synopsis    [Flip complemented edges.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ntl_ManFlipEdges( Ntl_Man_t * p, Aig_Man_t * pAigCol )
+{
+    Ntl_Mod_t * pRoot;
+    Ntl_Obj_t * pObj;
+    Aig_Obj_t * pObjCol, * pFanin;
+    int i, iLatch;
+    pRoot = Ntl_ManRootModel(p);
+    iLatch = 0;
+    Ntl_ModelForEachLatch( pRoot, pObj, i )
+    {
+        if ( (pObj->LatchId & 3) == 1 )
+        {
+            pObjCol = Aig_ManPi( pAigCol, Ntl_ModelPiNum(pRoot) + iLatch );
+            assert( pObjCol->fMarkA == 0 );
+            pObjCol->fMarkA = 1;
+        }
+        iLatch++;
+    }
+    // flip pointers to the complemented edges
+    Aig_ManForEachObj( pAigCol, pObjCol, i )
+    {
+        pFanin = Aig_ObjFanin0(pObjCol);
+        if ( pFanin && pFanin->fMarkA )
+            pObjCol->pFanin0 = Aig_Not(pObjCol->pFanin0);
+        pFanin = Aig_ObjFanin1(pObjCol);
+        if ( pFanin && pFanin->fMarkA )
+            pObjCol->pFanin1 = Aig_Not(pObjCol->pFanin1);
+    }
+    // flip complemented latch derivers and undo the marks
+    iLatch = 0;
+    Ntl_ModelForEachLatch( pRoot, pObj, i )
+    {
+        if ( (pObj->LatchId & 3) == 1 )
+        {
+            // flip the latch input
+            pObjCol = Aig_ManPo( pAigCol, Ntl_ModelPoNum(pRoot) + iLatch );
+            pObjCol->pFanin0 = Aig_Not(pObjCol->pFanin0);
+            // unmark the latch output
+            pObjCol = Aig_ManPi( pAigCol, Ntl_ModelPiNum(pRoot) + iLatch );
+            assert( pObjCol->fMarkA == 1 );
+            pObjCol->fMarkA = 0;
+        }
+        iLatch++;
+    }
+}
+
+/**Function*************************************************************
+
   Synopsis    [Returns AIG with WB after sequential SAT sweeping.]
 
   Description []
@@ -473,13 +550,14 @@ Ntl_Man_t * Ntl_ManSsw2( Ntl_Man_t * p, Fra_Ssw_t * pPars )
     Ntl_Man_t * pNew;
     Aig_Man_t * pAigRed, * pAigCol;
     // collapse the AIG
-    pAigCol = Ntl_ManCollapse( p );
+    pAigCol = Ntl_ManCollapse( p, 1 );
     pAigCol->nRegs = Ntl_ModelLatchNum(Ntl_ManRootModel(p));
     // transform the collapsed AIG
     pAigRed = Fra_FraigInduction( pAigCol, pPars );
     Aig_ManStop( pAigRed );
     pAigRed = Aig_ManDupReprBasic( pAigCol );
     // insert the result back
+    Ntl_ManFlipEdges( p, pAigRed );
     Ntl_ManTransferCopy( p );
     pNew = Ntl_ManInsertAig( p, pAigRed );
     // attach the white-boxes

src/aig/ntl/ntlMan.c

@@ -39,7 +39,7 @@
   SeeAlso     []
 
 ***********************************************************************/
-Ntl_Man_t * Ntl_ManAlloc( char * pFileName )
+Ntl_Man_t * Ntl_ManAlloc()
 {
     Ntl_Man_t * p;
     // start the manager
@@ -53,9 +53,6 @@ Ntl_Man_t * Ntl_ManAlloc( char * pFileName )
     // start the manager
     p->pMemObjs = Aig_MmFlexStart();
     p->pMemSops = Aig_MmFlexStart();
-    // same the names
-    p->pName = Ntl_ManStoreFileName( p, pFileName );
-    p->pSpec = Ntl_ManStoreName( p, pFileName );
     return p;
 }
 
@@ -106,7 +103,9 @@ Ntl_Man_t * Ntl_ManStartFrom( Ntl_Man_t * pOld )
     Ntl_Obj_t * pBox;
     Ntl_Net_t * pNet;
     int i, k;
-    pNew = Ntl_ManAlloc( pOld->pSpec );
+    pNew = Ntl_ManAlloc();
+    pNew->pName = Ntl_ManStoreFileName( pNew, pOld->pName );
+    pNew->pSpec = Ntl_ManStoreName( pNew, pOld->pName );
     Vec_PtrForEachEntry( pOld->vModels, pModel, i )
         if ( i == 0 )
         {
@@ -146,7 +145,9 @@ Ntl_Man_t * Ntl_ManDup( Ntl_Man_t * pOld )
     Ntl_Obj_t * pBox;
     Ntl_Net_t * pNet;
     int i, k;
-    pNew = Ntl_ManAlloc( pOld->pSpec );
+    pNew = Ntl_ManAlloc();
+    pNew->pName = Ntl_ManStoreFileName( pNew, pOld->pName );
+    pNew->pSpec = Ntl_ManStoreName( pNew, pOld->pName );
     Vec_PtrForEachEntry( pOld->vModels, pModel, i )
         pModel->pCopy = Ntl_ModelDup( pNew, pModel );
     Vec_PtrForEachEntry( pOld->vModels, pModel, i )
@@ -213,6 +214,22 @@ int Ntl_ManIsComb( Ntl_Man_t * p )
 
 /**Function*************************************************************
 
+  Synopsis    [Returns the number of registers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Ntl_ManLatchNum( Ntl_Man_t * p )          
+{ 
+    return Ntl_ModelLatchNum(Ntl_ManRootModel(p)); 
+} 
+
+/**Function*************************************************************
+
   Synopsis    [Find the model with the given name.]
 
   Description []

src/aig/ntl/ntlReadBlif.c

@@ -131,6 +131,8 @@ Ntl_Man_t * Ioa_ReadBlif( char * pFileName, int fCheck )
     }
     // set the design name
     p->pDesign = Ntl_ManAlloc( pFileName );
+    p->pDesign->pName = Ntl_ManStoreFileName( p->pDesign, pFileName );
+    p->pDesign->pSpec = Ntl_ManStoreName( p->pDesign, pFileName );
     // prepare the file for parsing
     Ioa_ReadReadPreparse( p );
     // parse interfaces of each network

src/aig/ntl/ntlWriteBlif.c

@@ -141,7 +141,7 @@ void Ioa_WriteBlifModel( FILE * pFile, Ntl_Mod_t * pModel )
 
 /**Function*************************************************************
 
-  Synopsis    [Writes the network into the BLIF file.]
+  Synopsis    [Writes the netlist into the BLIF file.]
 
   Description []
                
@@ -170,6 +170,25 @@ void Ioa_WriteBlif( Ntl_Man_t * p, char * pFileName )
     fclose( pFile );
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Writes the logic network into the BLIF file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ioa_WriteBlifLogic( Nwk_Man_t * pNtk, Ntl_Man_t * p, char * pFileName )
+{
+    Ntl_Man_t * pNew;
+    pNew = Ntl_ManInsertNtk( p, pNtk );
+    Ioa_WriteBlif( pNew, pFileName );
+    Ntl_ManFree( pNew );
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////

src/aig/nwk/nwk.h

@@ -250,7 +250,7 @@ extern Vec_Ptr_t *     Nwk_ManRetimeCutBackward( Nwk_Man_t * pMan, int nLatches,
 /*=== nwkMan.c ============================================================*/
 extern Nwk_Man_t *     Nwk_ManAlloc();
 extern void            Nwk_ManFree( Nwk_Man_t * p );
-extern void            Nwk_ManPrintStats( Nwk_Man_t * p, If_Lib_t * pLutLib );
+extern void            Nwk_ManPrintStats( Nwk_Man_t * p, If_Lib_t * pLutLib, int fSaveBest, int fDumpResult, void * pNtl );
 /*=== nwkMap.c ============================================================*/
 extern Nwk_Man_t *     Nwk_MappingIf( Aig_Man_t * p, Tim_Man_t * pManTime, If_Par_t * pPars );
 /*=== nwkObj.c ============================================================*/

src/aig/nwk/nwkFanio.c

@@ -125,58 +125,6 @@ static inline int Nwk_ObjReallocIsNeeded( Nwk_Obj_t * pObj )
 {  
     return pObj->nFanins + pObj->nFanouts == pObj->nFanioAlloc;
 }
-
-/**Function*************************************************************
-
-  Synopsis    [Reallocates the object.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Nwk_Obj_t * Nwk_ManReallocNode_old( Nwk_Obj_t * pObj )
-{  
-    Nwk_Obj_t * pObjNew, * pTemp;
-    int i, iNum;
-    assert( Nwk_ObjReallocIsNeeded(pObj) );
-    pObjNew = (Nwk_Obj_t *)Aig_MmFlexEntryFetch( pObj->pMan->pMemObjs, sizeof(Nwk_Obj_t) + 2 * pObj->nFanioAlloc * sizeof(Nwk_Obj_t *) );
-    memmove( pObjNew, pObj, sizeof(Nwk_Obj_t) + pObj->nFanioAlloc * sizeof(Nwk_Obj_t *) );
-    pObjNew->nFanioAlloc = 2 * pObj->nFanioAlloc;
-    // update the fanouts' fanins
-    Nwk_ObjForEachFanout( pObj, pTemp, i )
-    {
-        iNum = Nwk_ObjFindFanin( pTemp, pObj );
-        if ( iNum == -1 )
-            printf( "Nwk_ManReallocNode(): Error! Fanin cannot be found.\n" );
-        pTemp->pFanio[iNum] = pObjNew;
-    }
-    // update the fanins' fanouts
-    Nwk_ObjForEachFanin( pObj, pTemp, i )
-    {
-        iNum = Nwk_ObjFindFanout( pTemp, pObj );
-        if ( iNum == -1 )
-            printf( "Nwk_ManReallocNode(): Error! Fanout cannot be found.\n" );
-        pTemp->pFanio[pTemp->nFanins+iNum] = pObjNew;
-    }
-    memset( pObj, 0, sizeof(Nwk_Obj_t) + pObj->nFanioAlloc * sizeof(Nwk_Obj_t *) );
-    assert( Nwk_ManObj(pObjNew->pMan, pObjNew->Id) == pObj );
-    Vec_PtrWriteEntry( pObjNew->pMan->vObjs, pObjNew->Id, pObjNew );
-    if ( Nwk_ObjIsCi(pObjNew) )
-    {
-        assert( Nwk_ManCi(pObjNew->pMan, pObjNew->PioId) == pObj );
-        Vec_PtrWriteEntry( pObjNew->pMan->vCis, pObjNew->PioId, pObjNew );
-    }
-    if ( Nwk_ObjIsCo(pObjNew) )
-    {
-        assert( Nwk_ManCo(pObjNew->pMan, pObjNew->PioId) == pObj );
-        Vec_PtrWriteEntry( pObjNew->pMan->vCos, pObjNew->PioId, pObjNew );
-    }
-    pObjNew->pMan->nRealloced++;
-    return pObjNew;
-}
  
 /**Function*************************************************************
 
@@ -200,7 +148,6 @@ static Nwk_Obj_t * Nwk_ManReallocNode( Nwk_Obj_t * pObj )
     return NULL;
 }
 
-
 /**Function*************************************************************
 
   Synopsis    [Creates fanout/fanin relationship between the nodes.]

src/aig/nwk/nwkFlow.c

@@ -524,7 +524,7 @@ Vec_Ptr_t * Nwk_ManRetimeCutBackward( Nwk_Man_t * pMan, int nLatches, int fVerbo
         pObj->MarkA = 1;
     Nwk_ManForEachPoSeq( pMan, pObj, i )
         Nwk_ManMarkTfiCone_rec( pObj );
-    Nwk_ManForEachObj( pMan, pObj, i )
+    Nwk_ManForEachNode( pMan, pObj, i )
         if ( Nwk_ObjFaninNum(pObj) == 0 )
             pObj->MarkA = 1;
     // start flow computation from each LI driver

src/aig/nwk/nwkMan.c

@@ -104,6 +104,92 @@ void Nwk_ManPrintLutSizes( Nwk_Man_t * p, If_Lib_t * pLutLib )
 
 /**Function*************************************************************
 
+  Synopsis    [If the network is best, saves it in "best.blif" and returns 1.]
+
+  Description [If the networks are incomparable, saves the new network, 
+  returns its parameters in the internal parameter structure, and returns 1.
+  If the new network is not a logic network, quits without saving and returns 0.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Nwk_ManCompareAndSaveBest( Nwk_Man_t * pNtk, void * pNtl )
+{
+    extern void Ioa_WriteBlifLogic( Nwk_Man_t * pNtk, void * pNtl, char * pFileName );
+    static struct ParStruct {
+        char * pName;  // name of the best saved network
+        int    Depth;  // depth of the best saved network
+        int    Flops;  // flops in the best saved network 
+        int    Nodes;  // nodes in the best saved network
+        int    nPis;   // the number of primary inputs
+        int    nPos;   // the number of primary outputs
+    } ParsNew, ParsBest = { 0 };
+    // free storage for the name
+    if ( pNtk == NULL )
+    {
+        FREE( ParsBest.pName );
+        return 0;
+    }
+    // get the parameters
+    ParsNew.Depth = Nwk_ManLevel( pNtk );
+    ParsNew.Flops = Nwk_ManLatchNum( pNtk );
+    ParsNew.Nodes = Nwk_ManNodeNum( pNtk );
+    ParsNew.nPis  = Nwk_ManPiNum( pNtk );
+    ParsNew.nPos  = Nwk_ManPoNum( pNtk );
+    // reset the parameters if the network has the same name
+    if ( ParsBest.pName == NULL || 
+         strcmp(ParsBest.pName, pNtk->pName) ||
+         ParsBest.Depth >  ParsNew.Depth || 
+         ParsBest.Depth == ParsNew.Depth && ParsBest.Flops >  ParsNew.Flops || 
+         ParsBest.Depth == ParsNew.Depth && ParsBest.Flops == ParsNew.Flops && ParsBest.Nodes >  ParsNew.Nodes )
+    {
+        FREE( ParsBest.pName );
+        ParsBest.pName = Aig_UtilStrsav( pNtk->pName );
+        ParsBest.Depth = ParsNew.Depth; 
+        ParsBest.Flops = ParsNew.Flops; 
+        ParsBest.Nodes = ParsNew.Nodes; 
+        ParsBest.nPis  = ParsNew.nPis; 
+        ParsBest.nPos  = ParsNew.nPos;
+        // writ the network
+        Ioa_WriteBlifLogic( pNtk, pNtl, "best.blif" );
+        return 1;
+    }
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Nwk_FileNameGeneric( char * FileName )
+{
+    char * pDot;
+    char * pUnd;
+    char * pRes;
+    // find the generic name of the file
+    pRes = Aig_UtilStrsav( FileName );
+    // find the pointer to the "." symbol in the file name
+//  pUnd = strstr( FileName, "_" );
+    pUnd = NULL;
+    pDot = strstr( FileName, "." );
+    if ( pUnd )
+        pRes[pUnd - FileName] = 0;
+    else if ( pDot )
+        pRes[pDot - FileName] = 0;
+    return pRes;
+}
+
+/**Function*************************************************************
+
   Synopsis    [Prints stats of the manager.]
 
   Description []
@@ -113,24 +199,37 @@ void Nwk_ManPrintLutSizes( Nwk_Man_t * p, If_Lib_t * pLutLib )
   SeeAlso     []
 
 ***********************************************************************/
-void Nwk_ManPrintStats( Nwk_Man_t * p, If_Lib_t * pLutLib )
+void Nwk_ManPrintStats( Nwk_Man_t * pNtk, If_Lib_t * pLutLib, int fSaveBest, int fDumpResult, void * pNtl )
 {
-    p->pLutLib = pLutLib;
-    printf( "%-15s : ",      p->pName );
-    printf( "pi = %5d  ",    Nwk_ManPiNum(p) );
-    printf( "po = %5d  ",    Nwk_ManPoNum(p) );
-    printf( "ci = %5d  ",    Nwk_ManCiNum(p) );
-    printf( "co = %5d  ",    Nwk_ManCoNum(p) );
-    printf( "lat = %5d  ",   Nwk_ManLatchNum(p) );
-    printf( "node = %5d  ",  Nwk_ManNodeNum(p) );
-    printf( "edge = %5d  ",  Nwk_ManGetTotalFanins(p) );
-    printf( "aig = %6d  ",   Nwk_ManGetAigNodeNum(p) );
-    printf( "lev = %3d  ",   Nwk_ManLevel(p) );
-//    printf( "lev2 = %3d  ",  Nwk_ManLevelBackup(p) );
-    printf( "delay = %5.2f   ", Nwk_ManDelayTraceLut(p) );
-    Nwk_ManPrintLutSizes( p, pLutLib );
+    extern int Ntl_ManLatchNum( void * p );
+    extern void Ioa_WriteBlifLogic( Nwk_Man_t * pNtk, void * pNtl, char * pFileName );
+    if ( fSaveBest )
+        Nwk_ManCompareAndSaveBest( pNtk, pNtl );
+    if ( fDumpResult )
+    {
+        char Buffer[1000] = {0};
+        char * pNameGen = pNtk->pSpec? Nwk_FileNameGeneric( pNtk->pSpec ) : "nameless_";
+        sprintf( Buffer, "%s_dump.blif", pNameGen );
+        Ioa_WriteBlifLogic( pNtk, pNtl, Buffer );
+        if ( pNtk->pSpec ) free( pNameGen );
+    }
+
+    pNtk->pLutLib = pLutLib;
+    printf( "%-15s : ",      pNtk->pName );
+    printf( "pi = %5d  ",    Nwk_ManPiNum(pNtk) );
+    printf( "po = %5d  ",    Nwk_ManPoNum(pNtk) );
+    printf( "ci = %5d  ",    Nwk_ManCiNum(pNtk) );
+    printf( "co = %5d  ",    Nwk_ManCoNum(pNtk) );
+    printf( "lat = %5d  ",   Ntl_ManLatchNum(pNtl) );
+    printf( "node = %5d  ",  Nwk_ManNodeNum(pNtk) );
+    printf( "edge = %5d  ",  Nwk_ManGetTotalFanins(pNtk) );
+    printf( "aig = %6d  ",   Nwk_ManGetAigNodeNum(pNtk) );
+    printf( "lev = %3d  ",   Nwk_ManLevel(pNtk) );
+//    printf( "lev2 = %3d  ",  Nwk_ManLevelBackup(pNtk) );
+    printf( "delay = %5.2f   ", Nwk_ManDelayTraceLut(pNtk) );
+    Nwk_ManPrintLutSizes( pNtk, pLutLib );
     printf( "\n" );
-//    Nwk_ManDelayTracePrint( p, pLutLib );
+//    Nwk_ManDelayTracePrint( pNtk, pLutLib );
     fflush( stdout );
 }
 

src/aig/nwk/nwkMap.c

@@ -267,6 +267,9 @@ Nwk_Man_t * Nwk_ManFromIf( If_Man_t * pIfMan, Aig_Man_t * p, Vec_Ptr_t * vAigToI
     pNtk = Nwk_ManAlloc();
     pNtk->pName = Aig_UtilStrsav( p->pName );
     pNtk->pSpec = Aig_UtilStrsav( p->pSpec );
+//    pNtk->nLatches = Aig_ManRegNum(p);
+//    pNtk->nTruePis = Nwk_ManCiNum(pNtk) - pNtk->nLatches;
+//    pNtk->nTruePos = Nwk_ManCoNum(pNtk) - pNtk->nLatches;
     Aig_ManForEachObj( p, pObj, i )
     {
         pIfObj = Vec_PtrEntry( vAigToIf, i );

src/aig/nwk/nwkTiming.c

@@ -427,7 +427,7 @@ int Nwk_ManVerifyTiming(  Nwk_Man_t * pNtk )
     int i;
     Nwk_ManForEachObj( pNtk, pObj, i )
     {
-        if ( Nwk_ObjIsPi(pObj) && Nwk_ObjFanoutNum(pObj) == 0 )
+        if ( Nwk_ObjIsCi(pObj) && Nwk_ObjFanoutNum(pObj) == 0 )
             continue;
         tArrival = Nwk_NodeComputeArrival( pObj, 1 );
         tRequired = Nwk_NodeComputeRequired( pObj, 1 );

src/base/abci/abc.c

@@ -11935,8 +11935,8 @@ int Abc_CommandDRetime( Abc_Frame_t * pAbc, int argc, char ** argv )
 
     // set defaults
     fMinArea  = 1;
-    fForwardOnly = 1;
-    fBackwardOnly = 0;
+    fForwardOnly = 0;
+    fBackwardOnly = 1;
     nStepsMax = 100000;
     fFastAlgo = 1;
     fVerbose  = 0;
@@ -15315,15 +15315,25 @@ usage:
 int Abc_CommandAbc8Ps( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
     int c;
+    int fSaveBest;
+    int fDumpResult;
     extern void Ntl_ManPrintStats( void * p );
-    extern void Nwk_ManPrintStats( void * p, void * pLutLib );
+    extern void Nwk_ManPrintStats( void * p, void * pLutLib, int fSaveBest, int fDumpResult, void * pNtl );
 
     // set defaults
+    fSaveBest = 0;
+    fDumpResult = 0;
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "bdh" ) ) != EOF )
     {
         switch ( c )
         {
+        case 'b':
+            fSaveBest ^= 1;
+            break;
+        case 'd':
+            fDumpResult ^= 1;
+            break;
         case 'h':
             goto usage;
         default:
@@ -15350,13 +15360,15 @@ int Abc_CommandAbc8Ps( Abc_Frame_t * pAbc, int argc, char ** argv )
     if ( pAbc->pAbc8Nwk )
     {
         printf( "MAPPED:  " );
-        Nwk_ManPrintStats( pAbc->pAbc8Nwk, pAbc->pAbc8Lib );
+        Nwk_ManPrintStats( pAbc->pAbc8Nwk, pAbc->pAbc8Lib, fSaveBest, fDumpResult, pAbc->pAbc8Ntl );
     }
     return 0;
 
 usage:
-    fprintf( stdout, "usage: *ps [-h]\n" );
+    fprintf( stdout, "usage: *ps [-bdh]\n" );
     fprintf( stdout, "\t        prints design statistics\n" );
+    fprintf( stdout, "\t-b    : toggles saving the best logic network in \"best.blif\" [default = %s]\n", fSaveBest? "yes": "no" );
+    fprintf( stdout, "\t-d    : toggles dumping network into file \"<input_file_name>_dump.blif\" [default = %s]\n", fDumpResult? "yes": "no" );
     fprintf( stdout, "\t-h    : print the command usage\n");
     return 1;
 }
@@ -16939,7 +16951,7 @@ int Abc_CommandAbc8Cec( Abc_Frame_t * pAbc, int argc, char ** argv )
     int nConfLimit;
     int fSmart;
     int nPartSize;
-    extern Aig_Man_t * Ntl_ManCollapse( void * p );
+    extern Aig_Man_t * Ntl_ManCollapse( void * p, int fSeq );
     extern void * Ntl_ManDup( void * pOld );
     extern void Ntl_ManFree( void * p );
     extern void * Ntl_ManInsertNtk( void * p, void * pNtk );
@@ -17020,14 +17032,14 @@ int Abc_CommandAbc8Cec( Abc_Frame_t * pAbc, int argc, char ** argv )
     }
 
     // derive AIGs
-    pAig1 = Ntl_ManCollapse( pAbc->pAbc8Ntl );
+    pAig1 = Ntl_ManCollapse( pAbc->pAbc8Ntl, 0 );
     pTemp = Ntl_ManInsertNtk( pAbc->pAbc8Ntl, pAbc->pAbc8Nwk );
     if ( pTemp == NULL )
     {
         printf( "Abc_CommandAbc8Cec(): Inserting the design has failed.\n" );
         return 1;
     }
-    pAig2 = Ntl_ManCollapse( pTemp );
+    pAig2 = Ntl_ManCollapse( pTemp, 0 );
     Ntl_ManFree( pTemp );
 
     // perform verification