Version abc71216

abc.dsp

@@ -42,7 +42,7 @@ RSC=rc.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /W3 /GX /O2 /I "src/base/abc" /I "src/base/abci" /I "src/base/cmd" /I "src/base/io" /I "src/base/main" /I "src/base/ver" /I "src/bdd/cudd" /I "src/bdd/dsd" /I "src/bdd/epd" /I "src/bdd/mtr" /I "src/bdd/parse" /I "src/bdd/reo" /I "src/bdd/cas" /I "src/map/fpga" /I "src/map/mapper" /I "src/map/mio" /I "src/map/super" /I "src/map/if" /I "src/map/pcm" /I "src/map/ply" /I "src/misc/extra" /I "src/misc/mvc" /I "src/misc/st" /I "src/misc/util" /I "src/misc/espresso" /I "src/misc/nm" /I "src/misc/vec" /I "src/misc/hash" /I "src/opt/cut" /I "src/opt/dec" /I "src/opt/fxu" /I "src/opt/rwr" /I "src/opt/sim" /I "src/opt/ret" /I "src/opt/res" /I "src/opt/lpk" /I "src/sat/bsat" /I "src/sat/csat" /I "src/sat/msat" /I "src/sat/fraig" /I "src/aig/ivy" /I "src/aig/hop" /I "src/aig/rwt" /I "src/aig/deco" /I "src/aig/mem" /I "src/aig/dar" /I "src/aig/fra" /I "src/aig/cnf" /I "src/aig/csw" /I "src/aig/ioa" /I "src/aig/aig" /I "src/aig/kit" /I "src/aig/bdc" /I "src/aig/bar" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "src/base/abc" /I "src/base/abci" /I "src/base/cmd" /I "src/base/io" /I "src/base/main" /I "src/base/ver" /I "src/bdd/cudd" /I "src/bdd/dsd" /I "src/bdd/epd" /I "src/bdd/mtr" /I "src/bdd/parse" /I "src/bdd/reo" /I "src/bdd/cas" /I "src/map/fpga" /I "src/map/mapper" /I "src/map/mio" /I "src/map/super" /I "src/map/if" /I "src/map/pcm" /I "src/map/ply" /I "src/misc/extra" /I "src/misc/mvc" /I "src/misc/st" /I "src/misc/util" /I "src/misc/espresso" /I "src/misc/nm" /I "src/misc/vec" /I "src/misc/hash" /I "src/opt/cut" /I "src/opt/dec" /I "src/opt/fxu" /I "src/opt/rwr" /I "src/opt/sim" /I "src/opt/ret" /I "src/opt/res" /I "src/opt/lpk" /I "src/sat/bsat" /I "src/sat/csat" /I "src/sat/msat" /I "src/sat/fraig" /I "src/aig/ivy" /I "src/aig/hop" /I "src/aig/rwt" /I "src/aig/deco" /I "src/aig/mem" /I "src/aig/dar" /I "src/aig/fra" /I "src/aig/cnf" /I "src/aig/csw" /I "src/aig/ioa" /I "src/aig/aig" /I "src/aig/kit" /I "src/aig/bdc" /I "src/aig/bar" /I "src/aig/ntl" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /c
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -66,7 +66,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "src/base/abc" /I "src/base/abci" /I "src/base/cmd" /I "src/base/io" /I "src/base/main" /I "src/base/ver" /I "src/bdd/cudd" /I "src/bdd/dsd" /I "src/bdd/epd" /I "src/bdd/mtr" /I "src/bdd/parse" /I "src/bdd/reo" /I "src/bdd/cas" /I "src/map/fpga" /I "src/map/mapper" /I "src/map/mio" /I "src/map/super" /I "src/map/if" /I "src/map/pcm" /I "src/map/ply" /I "src/misc/extra" /I "src/misc/mvc" /I "src/misc/st" /I "src/misc/util" /I "src/misc/espresso" /I "src/misc/nm" /I "src/misc/vec" /I "src/misc/hash" /I "src/opt/cut" /I "src/opt/dec" /I "src/opt/fxu" /I "src/opt/rwr" /I "src/opt/sim" /I "src/opt/ret" /I "src/opt/res" /I "src/opt/lpk" /I "src/sat/bsat" /I "src/sat/csat" /I "src/sat/msat" /I "src/sat/fraig" /I "src/aig/ivy" /I "src/aig/hop" /I "src/aig/rwt" /I "src/aig/deco" /I "src/aig/mem" /I "src/aig/dar" /I "src/aig/fra" /I "src/aig/cnf" /I "src/aig/csw" /I "src/aig/ioa" /I "src/aig/aig" /I "src/aig/kit" /I "src/aig/bdc" /I "src/aig/bar" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "src/base/abc" /I "src/base/abci" /I "src/base/cmd" /I "src/base/io" /I "src/base/main" /I "src/base/ver" /I "src/bdd/cudd" /I "src/bdd/dsd" /I "src/bdd/epd" /I "src/bdd/mtr" /I "src/bdd/parse" /I "src/bdd/reo" /I "src/bdd/cas" /I "src/map/fpga" /I "src/map/mapper" /I "src/map/mio" /I "src/map/super" /I "src/map/if" /I "src/map/pcm" /I "src/map/ply" /I "src/misc/extra" /I "src/misc/mvc" /I "src/misc/st" /I "src/misc/util" /I "src/misc/espresso" /I "src/misc/nm" /I "src/misc/vec" /I "src/misc/hash" /I "src/opt/cut" /I "src/opt/dec" /I "src/opt/fxu" /I "src/opt/rwr" /I "src/opt/sim" /I "src/opt/ret" /I "src/opt/res" /I "src/opt/lpk" /I "src/sat/bsat" /I "src/sat/csat" /I "src/sat/msat" /I "src/sat/fraig" /I "src/aig/ivy" /I "src/aig/hop" /I "src/aig/rwt" /I "src/aig/deco" /I "src/aig/mem" /I "src/aig/dar" /I "src/aig/fra" /I "src/aig/cnf" /I "src/aig/csw" /I "src/aig/ioa" /I "src/aig/aig" /I "src/aig/kit" /I "src/aig/bdc" /I "src/aig/bar" /I "src/aig/ntl" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "__STDC__" /FR /YX /FD /GZ /c
 # SUBTRACT CPP /X
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
@@ -2937,6 +2937,50 @@ SOURCE=.\src\aig\bar\bar.c
 SOURCE=.\src\aig\bar\bar.h
 # End Source File
 # End Group
+# Begin Group "ntl"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntl.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlAig.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlCheck.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlDfs.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlMan.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlMap.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlObj.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlReadBlif.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlTable.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\aig\ntl\ntlWriteBlif.c
+# End Source File
+# End Group
 # End Group
 # End Group
 # Begin Group "Header Files"

abc.rc

@@ -124,5 +124,5 @@ alias bmc2     "frames -i -F 10; orpos; iprove"
 
 alias t0       "r test/mc1.blif; st; test"
 alias t1       "r s27mc2.blif; st; test"
-alias t2       "r i/intel_001.aig; ps; test"
+alias t2       "r i/intel_001.aig; ps; indcut -v"
 

src/aig/aig/aig.h

@@ -404,7 +404,7 @@ extern void            Aig_ObjRemoveFanout( Aig_Man_t * p, Aig_Obj_t * pObj, Aig
 extern void            Aig_ManFanoutStart( Aig_Man_t * p );
 extern void            Aig_ManFanoutStop( Aig_Man_t * p );
 /*=== aigFrames.c ==========================================================*/
-extern Aig_Man_t *     Aig_ManFrames( Aig_Man_t * pAig, int nFs, int fInit, int fOuts, int fRegs, Aig_Obj_t *** ppObjMap );
+extern Aig_Man_t *     Aig_ManFrames( Aig_Man_t * pAig, int nFs, int fInit, int fOuts, int fRegs, int fEnlarge, Aig_Obj_t *** ppObjMap );
 /*=== aigHaig.c ==========================================================*/
 extern void            Aig_ManHaigRecord( Aig_Man_t * p );
 /*=== aigMan.c ==========================================================*/

src/aig/aig/aigFrames.c

@@ -45,7 +45,7 @@ static inline Aig_Obj_t * Aig_ObjChild1Frames( Aig_Obj_t ** pObjMap, int nFs, Ai
   SeeAlso     []
 
 ***********************************************************************/
-Aig_Man_t * Aig_ManFrames( Aig_Man_t * pAig, int nFs, int fInit, int fOuts, int fRegs, Aig_Obj_t *** ppObjMap )
+Aig_Man_t * Aig_ManFrames( Aig_Man_t * pAig, int nFs, int fInit, int fOuts, int fRegs, int fEnlarge, Aig_Obj_t *** ppObjMap )
 {
     Aig_Man_t * pFrames;
     Aig_Obj_t * pObj, * pObjLi, * pObjLo, * pObjNew;
@@ -101,7 +101,7 @@ Aig_Man_t * Aig_ManFrames( Aig_Man_t * pAig, int nFs, int fInit, int fOuts, int
     }
     if ( fOuts )
     {
-        for ( f = 0; f < nFs; f++ )
+        for ( f = fEnlarge?nFs-1:0; f < nFs; f++ )
             Aig_ManForEachPoSeq( pAig, pObj, i )
             {
                 pObjNew = Aig_ObjCreatePo( pFrames, Aig_ObjChild0Frames(pObjMap,nFs,pObj,f) );
@@ -113,7 +113,7 @@ Aig_Man_t * Aig_ManFrames( Aig_Man_t * pAig, int nFs, int fInit, int fOuts, int
         pFrames->nRegs = pAig->nRegs;
         Aig_ManForEachLiSeq( pAig, pObj, i )
         {
-            pObjNew = Aig_ObjCreatePo( pFrames, Aig_ObjChild0Frames(pObjMap,nFs,pObj,nFs-1) );
+            pObjNew = Aig_ObjCreatePo( pFrames, Aig_ObjChild0Frames(pObjMap,nFs,pObj,fEnlarge?0:nFs-1) );
             Aig_ObjSetFrames( pObjMap, nFs, pObj, nFs-1, pObjNew );
         }
     }

src/aig/fra/fraClau.c

@@ -227,7 +227,7 @@ Cla_Man_t * Fra_ClauStart( Aig_Man_t * pMan )
     p->vCexBmc   = Vec_IntAlloc( Aig_ManRegNum(pMan) );
 
     // derive two timeframes to be checked
-    pFramesMain = Aig_ManFrames( pMan, 2, 0, 1, 0, NULL ); // nFrames, fInit, fOuts, fRegs
+    pFramesMain = Aig_ManFrames( pMan, 2, 0, 1, 0, 0, NULL ); // nFrames, fInit, fOuts, fRegs
 //Aig_ManShow( pFramesMain, 0, NULL );
     assert( Aig_ManPoNum(pFramesMain) == 2 );
     Aig_ObjChild0Flip( Aig_ManPo(pFramesMain, 0) ); // complement the first output
@@ -245,14 +245,14 @@ Cla_Man_t * Fra_ClauStart( Aig_Man_t * pMan )
 */
 
     // derive one timeframe to be checked
-    pFramesTest = Aig_ManFrames( pMan, 1, 0, 0, 1, NULL );
+    pFramesTest = Aig_ManFrames( pMan, 1, 0, 0, 1, 0, NULL );
     assert( Aig_ManPoNum(pFramesTest) == Aig_ManRegNum(pMan) );
     pCnfTest = Cnf_DeriveSimple( pFramesTest, Aig_ManRegNum(pMan) );
     p->pSatTest = Cnf_DataWriteIntoSolver( pCnfTest, 1, 0 );
     p->nSatVarsTestBeg = p->nSatVarsTestCur = sat_solver_nvars( p->pSatTest );
 
     // derive one timeframe to be checked for BMC
-    pFramesBmc = Aig_ManFrames( pMan, 1, 1, 0, 1, NULL );
+    pFramesBmc = Aig_ManFrames( pMan, 1, 1, 0, 1, 0, NULL );
 //Aig_ManShow( pFramesBmc, 0, NULL );
     assert( Aig_ManPoNum(pFramesBmc) == Aig_ManRegNum(pMan) );
     pCnfBmc = Cnf_DeriveSimple( pFramesBmc, Aig_ManRegNum(pMan) );

src/aig/fra/fraImp.c

@@ -345,6 +345,8 @@ Vec_Int_t * Fra_ImpDerive( Fra_Man_t * p, int nImpMaxLimit, int nImpUseLimit, in
     for ( k = pSeq->nWordsTotal * 32; k > 0; k-- )
         for ( i = k - 1; i > 0; i-- )
         {
+            // HERE WE ARE MISSING SOME POTENTIAL IMPLICATIONS (with complement!)
+
             for ( pNodesI = Vec_PtrEntry( vNodes, i ); *pNodesI; pNodesI++ )
             for ( pNodesK = Vec_PtrEntry( vNodes, k ); *pNodesK; pNodesK++ )
             {

src/aig/kit/kitFactor.c

@@ -56,7 +56,7 @@ Kit_Graph_t * Kit_SopFactor( Vec_Int_t * vCover, int fCompl, int nVars, Vec_Int_
     Kit_Edge_t eRoot;
 //    int nCubes;
 
-    // works for up to 15 variables because divisin procedure
+    // works for up to 15 variables because division procedure
     // used the last bit for marking the cubes going to the remainder
     assert( nVars < 16 );
 

src/aig/ntl/ntlCheck.c

+/**CFile****************************************************************
+
+  FileName    [ntlCheck.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    [Checks consistency of the netlist.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntlCheck.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+#include "aig.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Ntl_ManCheck( Ntl_Man_t * pMan )
+{
+    // check that the models have unique names
+    // check that the models (except the first one) do not have boxes
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Ntl_ModelCheck( Ntl_Mod_t * pModel )
+{
+    return 1;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Reads the verilog file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ntl_ModelFixNonDrivenNets( Ntl_Mod_t * pModel )
+{ 
+    Vec_Ptr_t * vNets;
+    Ntl_Net_t * pNet;
+    Ntl_Obj_t * pNode;
+    int i;
+
+    if ( Ntl_ModelIsBlackBox(pModel) )
+        return;
+
+    // check for non-driven nets
+    vNets = Vec_PtrAlloc( 100 );
+    Ntl_ModelForEachNet( pModel, pNet, i )
+    {
+        if ( pNet->pDriver != NULL )
+            continue;
+        // add the constant 0 driver
+        pNode = Ntl_ModelCreateNode( pModel, 0 );
+        pNode->pSop = Ntl_ManStoreSop( pModel->pMan, " 0\n" );
+        Ntl_ModelSetNetDriver( pNode, pNet );
+        // add the net to those for which the warning will be printed
+        Vec_PtrPush( vNets, pNet );
+    }
+
+    // print the warning
+    if ( Vec_PtrSize(vNets) > 0 )
+    {
+        printf( "Warning: Constant-0 drivers added to %d non-driven nets in network \"%s\":\n", Vec_PtrSize(vNets), pModel->pName );
+        Vec_PtrForEachEntry( vNets, pNet, i )
+        {
+            printf( "%s%s", (i? ", ": ""), pNet->pName );
+            if ( i == 3 )
+            {
+                if ( Vec_PtrSize(vNets) > 3 )
+                    printf( " ..." );
+                break;
+            }
+        }
+        printf( "\n" );
+    }
+    Vec_PtrFree( vNets );
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntlDfs.c

+/**CFile****************************************************************
+
+  FileName    [ntlDfs.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    [DFS traversal.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntlDfs.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+
+/**Function*************************************************************
+
+  Synopsis    [Collects the nodes in a topological order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Ntl_ManDfs_rec( Ntl_Man_t * p, Ntl_Net_t * pNet )
+{
+    Ntl_Obj_t * pObj;
+    Ntl_Net_t * pNetFanin;
+    int i;
+    // skip visited
+    if ( pNet->nVisits == 2 ) 
+        return 1;
+    // if the node is on the path, this is a combinational loop
+    if ( pNet->nVisits == 1 )
+        return 0; 
+    // mark the node as the one on the path
+    pNet->nVisits = 1;
+    // derive the box
+    pObj = pNet->pDriver;
+    assert( Ntl_ObjIsNode(pObj) || Ntl_ObjIsBox(pObj) );
+    // visit the input nets of the box
+    Ntl_ObjForEachFanin( pObj, pNetFanin, i )
+        if ( !Ntl_ManDfs_rec( p, pNetFanin ) )
+            return 0;
+    // add box inputs/outputs to COs/CIs
+    if ( Ntl_ObjIsBox(pObj) )
+    {
+        Ntl_ObjForEachFanin( pObj, pNetFanin, i )
+            Vec_PtrPush( p->vCos, pNetFanin );
+        Ntl_ObjForEachFanout( pObj, pNetFanin, i )
+            Vec_PtrPush( p->vCis, pNetFanin );
+    }
+    // store the node
+    Vec_PtrPush( p->vNodes, pObj );
+    pNet->nVisits = 2;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs DFS.]
+
+  Description [Checks for combinational loops. Collects PI/PO nets.
+  Collects nodes in the topological order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Ntl_ManDfs( Ntl_Man_t * p )
+{
+    Ntl_Mod_t * pRoot;
+    Ntl_Obj_t * pObj;
+    Ntl_Net_t * pNet;
+    int i, nUselessObjects;
+    assert( Vec_PtrSize(p->vCis) == 0 );
+    assert( Vec_PtrSize(p->vCos) == 0 );
+    assert( Vec_PtrSize(p->vNodes) == 0 );
+    // get the root model
+    pRoot = Vec_PtrEntry( p->vModels, 0 );
+    // collect primary inputs
+    Ntl_ModelForEachPi( pRoot, pObj, i )
+    {
+        assert( Ntl_ObjNumFanouts(pObj) == 1 );
+        pNet = Ntl_ObjFanout0(pObj);
+        Vec_PtrPush( p->vCis, pNet );
+        if ( pNet->nVisits )
+        {
+            printf( "Ntl_ManDfs(): Primary input appears twice in the list.\n" );
+            return 0;
+        }
+        pNet->nVisits = 2;
+    }
+    // collect latch outputs
+    Ntl_ModelForEachLatch( pRoot, pObj, i )
+    {
+        assert( Ntl_ObjNumFanouts(pObj) == 1 );
+        pNet = Ntl_ObjFanout0(pObj);
+        Vec_PtrPush( p->vCis, pNet );
+        if ( pNet->nVisits )
+        {
+            printf( "Ntl_ManDfs(): Latch output is duplicated or defined as a primary input.\n" );
+            return 0;
+        }
+        pNet->nVisits = 2;
+    }
+    // visit the nodes starting from primary outputs
+    Ntl_ModelForEachPo( pRoot, pObj, i )
+    {
+        pNet = Ntl_ObjFanin0(pObj);
+        if ( !Ntl_ManDfs_rec( p, pNet ) )
+        {
+            printf( "Ntl_ManDfs(): Error: Combinational loop is detected.\n" );
+            Vec_PtrClear( p->vCis );
+            Vec_PtrClear( p->vCos );
+            Vec_PtrClear( p->vNodes );
+            return 0;
+        }
+        Vec_PtrPush( p->vCos, pNet );
+    }
+    // visit the nodes starting from latch inputs outputs
+    Ntl_ModelForEachLatch( pRoot, pObj, i )
+    {
+        pNet = Ntl_ObjFanin0(pObj);
+        if ( !Ntl_ManDfs_rec( p, pNet ) )
+        {
+            printf( "Ntl_ManDfs(): Error: Combinational loop is detected.\n" );
+            Vec_PtrClear( p->vCis );
+            Vec_PtrClear( p->vCos );
+            Vec_PtrClear( p->vNodes );
+            return 0;
+        }
+        Vec_PtrPush( p->vCos, pNet );
+    }
+    // report the number of dangling objects
+    nUselessObjects = Ntl_ModelNodeNum(pRoot) + Ntl_ModelBoxNum(pRoot) - Vec_PtrSize(p->vNodes);
+    if ( nUselessObjects )
+        printf( "The number of nodes that do not feed into POs = %d.\n", nUselessObjects );
+    return 1;    
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntlMan.c

+/**CFile****************************************************************
+
+  FileName    [ntlMan.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    [Netlist manager.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntlMan.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates the netlist manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Man_t * Ntl_ManAlloc( char * pFileName )
+{
+    Ntl_Man_t * p;
+    // start the manager
+    p = ALLOC( Ntl_Man_t, 1 );
+    memset( p, 0, sizeof(Ntl_Man_t) );
+    p->vModels = Vec_PtrAlloc( 1000 );
+    p->vCis = Vec_PtrAlloc( 1000 );
+    p->vCos = Vec_PtrAlloc( 1000 );
+    p->vNodes = Vec_PtrAlloc( 1000 );
+    // 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;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocates the netlist manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ntl_ManFree( Ntl_Man_t * p )
+{
+    if ( p->vModels )
+    {
+        Ntl_Mod_t * pModel;
+        int i;
+        Ntl_ManForEachModel( p, pModel, i )
+            Ntl_ModelFree( pModel );
+        Vec_PtrFree( p->vModels );
+    }
+    if ( p->vCis )     Vec_PtrFree( p->vCis );
+    if ( p->vCos )     Vec_PtrFree( p->vCos );
+    if ( p->vNodes )   Vec_PtrFree( p->vNodes );
+    if ( p->pMemObjs ) Aig_MmFlexStop( p->pMemObjs, 0 );
+    if ( p->pMemSops ) Aig_MmFlexStop( p->pMemSops, 0 );
+    if ( p->pAig )     Aig_ManStop( p->pAig );
+    free( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find the model with the given name.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Mod_t * Ntl_ManFindModel( Ntl_Man_t * p, char * pName )
+{
+    Ntl_Mod_t * pModel;
+    int i;
+    Vec_PtrForEachEntry( p->vModels, pModel, i )
+        if ( !strcmp( pModel->pName, pName ) )
+            return pModel;
+    return NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates the model.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Mod_t * Ntl_ModelAlloc( Ntl_Man_t * pMan, char * pName )
+{
+    Ntl_Mod_t * p;
+    // start the manager
+    p = ALLOC( Ntl_Mod_t, 1 );
+    memset( p, 0, sizeof(Ntl_Mod_t) );
+    p->pMan  = pMan;
+    p->pName = Ntl_ManStoreName( p->pMan, pName );
+    Vec_PtrPush( pMan->vModels, p );
+    p->vObjs = Vec_PtrAlloc( 10000 );
+    p->vPis  = Vec_PtrAlloc( 1000 );
+    p->vPos  = Vec_PtrAlloc( 1000 );
+    // start the table
+    p->nTableSize = Aig_PrimeCudd( 10000 );
+    p->pTable = ALLOC( Ntl_Net_t *, p->nTableSize );
+    memset( p->pTable, 0, sizeof(Ntl_Net_t *) * p->nTableSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocates the model.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ntl_ModelFree( Ntl_Mod_t * p )
+{
+    Vec_PtrFree( p->vObjs );
+    Vec_PtrFree( p->vPis );
+    Vec_PtrFree( p->vPos );
+    free( p->pTable );
+    free( p );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntlMap.c

+/**CFile****************************************************************
+
+  FileName    [ntlMap.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    [Derives mapped network from AIG.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntlMap.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates mapping for the given AIG.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Ntl_MappingAlloc( int nLuts, int nVars )
+{
+    char * pMemory;
+    Ntl_Lut_t ** pArray;
+    int nEntrySize, i;
+    nEntrySize = sizeof(Ntl_Lut_t) + sizeof(int) * nVars + sizeof(unsigned) * Aig_TruthWordNum(nVars);
+    pArray = (Ntl_Lut_t **)malloc( (sizeof(Ntl_Lut_t *) + nEntrySize) * nLuts );
+    pMemory = (char *)(pArray + nLuts);
+    memset( pMemory, 0, nEntrySize * nLuts );
+    for ( i = 0; i < nLuts; i++ )
+    {
+        pArray[i] = (Ntl_Lut_t *)pMemory;
+        pArray[i]->pFanins = (int *)(pMemory + sizeof(Ntl_Lut_t));
+        pArray[i]->pTruth = (unsigned *)(pMemory + sizeof(Ntl_Lut_t) + sizeof(int) * nVars);
+        pMemory += nEntrySize;
+    }
+    return Vec_PtrAllocArray( (void **)pArray, nLuts );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives trivial mapping from the AIG.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Ntl_MappingFromAig( Aig_Man_t * p )
+{
+    Vec_Ptr_t * vMapping;
+    Ntl_Lut_t * pLut;
+    Aig_Obj_t * pObj;
+    int i, k = 0, nBytes = 4;
+    vMapping = Ntl_MappingAlloc( Aig_ManAndNum(p) + (int)(Aig_ManConst1(p)->nRefs > 0), 2 );
+    if ( Aig_ManConst1(p)->nRefs > 0 )
+    {
+        pLut = Vec_PtrEntry( vMapping, k++ );
+        pLut->Id = 0;
+        pLut->nFanins = 0;
+        memset( pLut->pTruth, 0xFF, nBytes );
+    }
+    Aig_ManForEachNode( p, pObj, i )
+    {
+        pLut = Vec_PtrEntry( vMapping, k++ );
+        pLut->Id = pObj->Id;
+        pLut->nFanins = 2;
+        pLut->pFanins[0] = Aig_ObjFaninId0(pObj);
+        pLut->pFanins[1] = Aig_ObjFaninId1(pObj);
+        if      (  Aig_ObjFaninC0(pObj) &&  Aig_ObjFaninC1(pObj) ) 
+            memset( pLut->pTruth, 0x11, nBytes );
+        else if ( !Aig_ObjFaninC0(pObj) &&  Aig_ObjFaninC1(pObj) )
+            memset( pLut->pTruth, 0x22, nBytes );
+        else if (  Aig_ObjFaninC0(pObj) && !Aig_ObjFaninC1(pObj) )
+            memset( pLut->pTruth, 0x44, nBytes );
+        else if ( !Aig_ObjFaninC0(pObj) && !Aig_ObjFaninC1(pObj) )
+            memset( pLut->pTruth, 0x88, nBytes );
+    }
+    assert( k == Vec_PtrSize(vMapping) );
+    return vMapping;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntlObj.c

+/**CFile****************************************************************
+
+  FileName    [.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: .c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the primary input.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Obj_t * Ntl_ModelCreatePi( Ntl_Mod_t * pModel )
+{
+    Ntl_Obj_t * p;
+    p = (Ntl_Obj_t *)Aig_MmFlexEntryFetch( pModel->pMan->pMemObjs, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) );
+    memset( p, 0, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) );
+    p->Id = Vec_PtrSize( pModel->vObjs );
+    Vec_PtrPush( pModel->vObjs, p );
+    Vec_PtrPush( pModel->vPis, p );
+    p->pModel   = pModel;
+    p->Type     = NTL_OBJ_PI;
+    p->nFanins  = 0;
+    p->nFanouts = 1;
+    pModel->nObjs[NTL_OBJ_PI]++;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the primary output.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Obj_t * Ntl_ModelCreatePo( Ntl_Mod_t * pModel, Ntl_Net_t * pNet )
+{
+    Ntl_Obj_t * p;
+    p = (Ntl_Obj_t *)Aig_MmFlexEntryFetch( pModel->pMan->pMemObjs, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) );
+    memset( p, 0, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) );
+    p->Id = Vec_PtrSize( pModel->vObjs );
+    Vec_PtrPush( pModel->vObjs, p );
+    Vec_PtrPush( pModel->vPos, p );
+    p->pModel    = pModel;
+    p->Type      = NTL_OBJ_PO;
+    p->nFanins   = 1;
+    p->nFanouts  = 0;
+    p->pFanio[0] = pNet;
+    pModel->nObjs[NTL_OBJ_PO]++;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the primary output.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Obj_t * Ntl_ModelCreateLatch( Ntl_Mod_t * pModel )
+{
+    Ntl_Obj_t * p;
+    p = (Ntl_Obj_t *)Aig_MmFlexEntryFetch( pModel->pMan->pMemObjs, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) * 3 );
+    memset( p, 0, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) * 3 );
+    p->Id = Vec_PtrSize( pModel->vObjs );
+    Vec_PtrPush( pModel->vObjs, p );
+    p->pModel   = pModel;
+    p->Type     = NTL_OBJ_LATCH;
+    p->nFanins  = 2;
+    p->nFanouts = 1;
+    pModel->nObjs[NTL_OBJ_LATCH]++;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Obj_t * Ntl_ModelCreateNode( Ntl_Mod_t * pModel, int nFanins )
+{
+    Ntl_Obj_t * p;
+    p = (Ntl_Obj_t *)Aig_MmFlexEntryFetch( pModel->pMan->pMemObjs, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) * (nFanins + 1) );
+    memset( p, 0, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) * (nFanins + 1) );
+    p->Id = Vec_PtrSize( pModel->vObjs );
+    Vec_PtrPush( pModel->vObjs, p );
+    p->pModel   = pModel;
+    p->Type     = NTL_OBJ_NODE;
+    p->nFanins  = nFanins;
+    p->nFanouts = 1;
+    pModel->nObjs[NTL_OBJ_NODE]++;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Create the latch.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Obj_t * Ntl_ModelCreateBox( Ntl_Mod_t * pModel, int nFanins, int nFanouts )
+{
+    Ntl_Obj_t * p;
+    p = (Ntl_Obj_t *)Aig_MmFlexEntryFetch( pModel->pMan->pMemObjs, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) * (nFanins + nFanouts) );
+    memset( p, 0, sizeof(Ntl_Obj_t) + sizeof(Ntl_Net_t *) * (nFanins + nFanouts) );
+    p->Id = Vec_PtrSize( pModel->vObjs );
+    Vec_PtrPush( pModel->vObjs, p );
+    p->pModel   = pModel;
+    p->Type     = NTL_OBJ_BOX;
+    p->nFanins  = nFanins;
+    p->nFanouts = nFanouts;
+    pModel->nObjs[NTL_OBJ_BOX]++;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates memory and copies the name into it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Ntl_ManStoreName( Ntl_Man_t * p, char * pName )
+{
+    char * pStore;
+    pStore = Aig_MmFlexEntryFetch( p->pMemObjs, strlen(pName) + 1 );
+    strcpy( pStore, pName );
+    return pStore;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates memory and copies the SOP into it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Ntl_ManStoreSop( Ntl_Man_t * p, char * pSop )
+{
+    char * pStore;
+    pStore = Aig_MmFlexEntryFetch( p->pMemSops, strlen(pSop) + 1 );
+    strcpy( pStore, pSop );
+    return pStore;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates memory and copies the root of file name there.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Ntl_ManStoreFileName( Ntl_Man_t * p, char * pFileName )
+{
+    char * pBeg, * pEnd, * pStore, * pCur;
+    // find the first dot
+    for ( pEnd = pFileName; *pEnd; pEnd++ )
+        if ( *pEnd == '.' )
+            break;
+    // find the first char
+    for ( pBeg = pEnd - 1; pBeg >= pFileName; pBeg-- )
+        if ( !((*pBeg >= 'a' && *pBeg <= 'z') || (*pBeg >= 'A' && *pBeg <= 'Z') || (*pBeg >= '0' && *pBeg <= '9') || *pBeg == '_') )
+            break;
+    pBeg++;
+    // fill up storage
+    pStore = Aig_MmFlexEntryFetch( p->pMemSops, pEnd - pBeg + 1 );
+    for ( pCur = pStore; pBeg < pEnd; pBeg++, pCur++ )
+        *pCur = *pBeg;
+    *pCur = 0;
+    return pStore;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntlTable.c

+/**CFile****************************************************************
+
+  FileName    [ntlTable.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    [Name table manipulation.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntlTable.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+// hashing for strings
+static unsigned Ntl_HashString( char * pName, int TableSize ) 
+{
+    static int s_Primes[10] = { 
+        1291, 1699, 2357, 4177, 5147, 
+        5647, 6343, 7103, 7873, 8147
+    };
+    unsigned i, Key = 0;
+    for ( i = 0; pName[i] != '\0'; i++ )
+        Key ^= s_Primes[i%10]*pName[i]*pName[i];
+    return Key % TableSize;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates memory for the net.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Net_t * Ntl_ModelCreateNet( Ntl_Mod_t * p, char * pName )
+{
+    Ntl_Net_t * pNet;
+    pNet = (Ntl_Net_t *)Aig_MmFlexEntryFetch( p->pMan->pMemObjs, sizeof(Ntl_Net_t) + strlen(pName) + 1 );
+    memset( pNet, 0, sizeof(Ntl_Net_t) );
+    strcpy( pNet->pName, pName );
+    return pNet;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the table.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ntl_ModelTableResize( Ntl_Mod_t * p )
+{
+    Ntl_Net_t ** pTableNew, ** ppSpot, * pEntry, * pEntry2;
+    int nTableSizeNew, Counter, e, clk;
+clk = clock();
+    // get the new table size
+    nTableSizeNew = Aig_PrimeCudd( 3 * p->nTableSize ); 
+    // allocate a new array
+    pTableNew = ALLOC( Ntl_Net_t *, nTableSizeNew );
+    memset( pTableNew, 0, sizeof(Ntl_Net_t *) * nTableSizeNew );
+    // rehash entries 
+    Counter = 0;
+    for ( e = 0; e < p->nTableSize; e++ )
+        for ( pEntry = p->pTable[e], pEntry2 = pEntry? pEntry->pNext : NULL; 
+              pEntry; pEntry = pEntry2, pEntry2 = pEntry? pEntry->pNext : NULL )
+            {
+                ppSpot = pTableNew + Ntl_HashString( pEntry->pName, nTableSizeNew );
+                pEntry->pNext = *ppSpot;
+                *ppSpot = pEntry;
+                Counter++;
+            }
+    assert( Counter == p->nEntries );
+//    printf( "Increasing the structural table size from %6d to %6d. ", p->nTableSize, nTableSizeNew );
+//    PRT( "Time", clock() - clk );
+    // replace the table and the parameters
+    free( p->pTable );
+    p->pTable = pTableNew;
+    p->nTableSize = nTableSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Finds or creates the net.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Net_t * Ntl_ModelFindNet( Ntl_Mod_t * p, char * pName )
+{
+    Ntl_Net_t * pEnt;
+    unsigned Key = Ntl_HashString( pName, p->nTableSize );
+    for ( pEnt = p->pTable[Key]; pEnt; pEnt = pEnt->pNext )
+        if ( !strcmp( pEnt->pName, pName ) )
+            return pEnt;
+    return NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Finds or creates the net.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Ntl_Net_t * Ntl_ModelFindOrCreateNet( Ntl_Mod_t * p, char * pName )
+{
+    Ntl_Net_t * pEnt;
+    unsigned Key = Ntl_HashString( pName, p->nTableSize );
+    for ( pEnt = p->pTable[Key]; pEnt; pEnt = pEnt->pNext )
+        if ( !strcmp( pEnt->pName, pName ) )
+            return pEnt;
+    pEnt = Ntl_ModelCreateNet( p, pName );
+    pEnt->pNext = p->pTable[Key];
+    p->pTable[Key] = pEnt;
+    if ( ++p->nEntries > 2 * p->nTableSize )
+        Ntl_ModelTableResize( p );
+    return pEnt;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Finds or creates the net.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Ntl_ModelSetNetDriver( Ntl_Obj_t * pObj, Ntl_Net_t * pNet )
+{
+    if ( pObj->pFanio[pObj->nFanins] != NULL )
+        return 0;
+    if ( pNet->pDriver != NULL )
+        return 0;
+    pObj->pFanio[pObj->nFanins] = pNet;
+    pNet->pDriver = pObj;
+    return 1;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntlWriteBlif.c

+/**CFile****************************************************************
+
+  FileName    [ntlWriteBlif.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Command processing package.]
+
+  Synopsis    [Procedures to write BLIF files.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntlWriteBlif.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+#include "ioa.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Writes one model into the BLIF file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ioa_WriteBlifModel( FILE * pFile, Ntl_Mod_t * pModel )
+{
+    Ntl_Obj_t * pObj;
+    Ntl_Net_t * pNet;
+    int i, k;
+    fprintf( pFile, ".model %s\n", pModel->pName );
+    fprintf( pFile, ".inputs" );
+    Ntl_ModelForEachPi( pModel, pObj, i )
+        fprintf( pFile, " %s", Ntl_ObjFanout0(pObj)->pName );
+    fprintf( pFile, "\n" );
+    fprintf( pFile, ".outputs" );
+    Ntl_ModelForEachPo( pModel, pObj, i )
+        fprintf( pFile, " %s", Ntl_ObjFanin0(pObj)->pName );
+    fprintf( pFile, "\n" );
+    Ntl_ModelForEachObj( pModel, pObj, i )
+    {
+        if ( Ntl_ObjIsNode(pObj) )
+        {
+            fprintf( pFile, ".names" );
+            Ntl_ObjForEachFanin( pObj, pNet, k )
+                fprintf( pFile, " %s", pNet->pName );
+            fprintf( pFile, " %s\n", Ntl_ObjFanout0(pObj)->pName );
+            fprintf( pFile, "%s", pObj->pSop );
+        }
+        else if ( Ntl_ObjIsLatch(pObj) )
+        {
+            fprintf( pFile, ".latch" );
+            fprintf( pFile, " %s", Ntl_ObjFanin0(pObj)->pName );
+            fprintf( pFile, " %s", Ntl_ObjFanout0(pObj)->pName );
+            if ( pObj->LatchId >> 2 )
+                fprintf( pFile, " %d", pObj->LatchId >> 2 );
+            if ( pObj->pFanio[1] != NULL )
+                fprintf( pFile, " %s", Ntl_ObjFanin(pObj, 1)->pName );
+            fprintf( pFile, " %d", pObj->LatchId & 3 );
+            fprintf( pFile, "\n" );
+        }
+        else if ( Ntl_ObjIsBox(pObj) )
+        {
+            fprintf( pFile, ".subckt %s", pObj->pImplem->pName );
+            Ntl_ObjForEachFanin( pObj, pNet, k )
+                fprintf( pFile, " %s=%s", Ntl_ModelPiName(pObj->pImplem, k), pNet->pName );
+            Ntl_ObjForEachFanout( pObj, pNet, k )
+                fprintf( pFile, " %s=%s", Ntl_ModelPoName(pObj->pImplem, k), pNet->pName );
+            fprintf( pFile, "\n" );
+        }
+    }
+    fprintf( pFile, ".end\n\n" );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the network into the BLIF file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Ioa_WriteBlif( Ntl_Man_t * p, char * pFileName )
+{
+    FILE * pFile;
+    Ntl_Mod_t * pModel;
+    int i;
+    // start the output stream
+    pFile = fopen( pFileName, "w" );
+    if ( pFile == NULL )
+    {
+        fprintf( stdout, "Ioa_WriteBlif(): Cannot open the output file \"%s\".\n", pFileName );
+        return;
+    }
+    fprintf( pFile, "# Benchmark \"%s\" written by ABC-8 on %s\n", p->pName, Ioa_TimeStamp() );
+    // write the models
+    Ntl_ManForEachModel( p, pModel, i )
+        Ioa_WriteBlifModel( pFile, pModel );
+    // close the file
+    fclose( pFile );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/aig/ntl/ntl_.c

+/**CFile****************************************************************
+
+  FileName    [ntl_.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Netlist representation.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: ntl_.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ntl.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+

src/base/abci/abcDar.c

@@ -211,6 +211,18 @@ Abc_Ntk_t * Abc_NtkFromDarSeqSweep( Abc_Ntk_t * pNtkOld, Aig_Man_t * pMan )
 //    assert( Aig_ManRegNum(pMan) != Abc_NtkLatchNum(pNtkOld) );
     // perform strashing
     pNtkNew = Abc_NtkStartFromNoLatches( pNtkOld, ABC_NTK_STRASH, ABC_FUNC_AIG );
+    // consider the case of target enlargement
+    if ( Abc_NtkCiNum(pNtkNew) < Aig_ManPiNum(pMan) - Aig_ManRegNum(pMan) )
+    {
+        for ( i = Aig_ManPiNum(pMan) - Aig_ManRegNum(pMan) - Abc_NtkCiNum(pNtkNew); i > 0; i-- )
+        {
+            pObjNew = Abc_NtkCreatePi( pNtkNew );
+            Abc_ObjAssignName( pObjNew, Abc_ObjName(pObjNew), NULL );
+        }
+        Abc_NtkOrderCisCos( pNtkNew );
+    }
+    assert( Abc_NtkCiNum(pNtkNew) == Aig_ManPiNum(pMan) - Aig_ManRegNum(pMan) );
+    assert( Abc_NtkCoNum(pNtkNew) == Aig_ManPoNum(pMan) - Aig_ManRegNum(pMan) );
     // transfer the pointers to the basic nodes
     Aig_ManConst1(pMan)->pData = Abc_AigConst1(pNtkNew);
     Aig_ManForEachPiSeq( pMan, pObj, i )
@@ -1040,7 +1052,13 @@ PRT( "Initial fraiging time", clock() - clk );
     if ( Aig_ManRegNum(pMan) < Abc_NtkLatchNum(pNtk) )
         pNtkAig = Abc_NtkFromDarSeqSweep( pNtk, pMan );
     else
+    {
+        Abc_Obj_t * pObj;
+        int i;
         pNtkAig = Abc_NtkFromDar( pNtk, pMan );
+        Abc_NtkForEachLatch( pNtkAig, pObj, i )
+            Abc_LatchSetInit0( pObj );
+    }
     Aig_ManStop( pMan );
     return pNtkAig;
 }
@@ -1068,7 +1086,13 @@ Abc_Ntk_t * Abc_NtkDarLcorr( Abc_Ntk_t * pNtk, int nFramesP, int nConfMax, int f
     if ( Aig_ManRegNum(pMan) < Abc_NtkLatchNum(pNtk) )
         pNtkAig = Abc_NtkFromDarSeqSweep( pNtk, pMan );
     else
+    {
+        Abc_Obj_t * pObj;
+        int i;
         pNtkAig = Abc_NtkFromDar( pNtk, pMan );
+        Abc_NtkForEachLatch( pNtkAig, pObj, i )
+            Abc_LatchSetInit0( pObj );
+    }
     Aig_ManStop( pMan );
     return pNtkAig;
 }
@@ -1409,10 +1433,10 @@ int Abc_NtkDarSeqSim( Abc_Ntk_t * pNtk, int nFrames, int nWords, int fVerbose )
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_NtkDarClau( Abc_Ntk_t * pNtk, int nFrames, int nStepsMax, int fBmc, int fVerbose, int fVeryVerbose )
+int Abc_NtkDarClau( Abc_Ntk_t * pNtk, int nFrames, int nPref, int nClauses, int fBmc, int fRefs, int fVerbose, int fVeryVerbose )
 {
     extern int Fra_Clau( Aig_Man_t * pMan, int nIters, int fVerbose, int fVeryVerbose );
-    extern int Fra_Claus( Aig_Man_t * pAig, int nFrames, int nClauses, int fBmc, int fVerbose, int fVeryVerbose );
+    extern int Fra_Claus( Aig_Man_t * pAig, int nFrames, int nPref, int nClauses, int fBmc, int fRefs, int fVerbose, int fVeryVerbose );
     Aig_Man_t * pMan;
     if ( Abc_NtkPoNum(pNtk) != 1 )
     {
@@ -1428,11 +1452,70 @@ int Abc_NtkDarClau( Abc_Ntk_t * pNtk, int nFrames, int nStepsMax, int fBmc, int
     pMan->vFlopNums = NULL;
 
 //    Fra_Clau( pMan, nStepsMax, fVerbose, fVeryVerbose );
-    Fra_Claus( pMan, nFrames, nStepsMax, fBmc, fVerbose, fVeryVerbose );
+    Fra_Claus( pMan, nFrames, nPref, nClauses, fBmc, fRefs, fVerbose, fVeryVerbose );
     Aig_ManStop( pMan );
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Performs targe enlargement.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkDarEnlarge( Abc_Ntk_t * pNtk, int nFrames, int fVerbose )
+{
+    Abc_Ntk_t * pNtkAig;
+    Aig_Man_t * pMan, * pTemp;
+    pMan = Abc_NtkToDar( pNtk, 1 );
+    if ( pMan == NULL )
+        return NULL;
+    pMan = Aig_ManFrames( pTemp = pMan, nFrames, 0, 1, 1, 1, NULL );
+    Aig_ManStop( pTemp );
+    pNtkAig = Abc_NtkFromDarSeqSweep( pNtk, pMan );
+    Aig_ManStop( pMan );
+    return pNtkAig;
+}
+
+
+#include "ntl.h"
+
+/**Function*************************************************************
+
+  Synopsis    [Performs targe enlargement.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkDarTestBlif( char * pFileName )
+{
+    char Buffer[1000];
+    Ntl_Man_t * p;
+    p = Ioa_ReadBlif( pFileName, 1 );
+    if ( p == NULL )
+    {
+        printf( "Abc_NtkDarTestBlif(): Reading BLIF has failed.\n" );
+        return;
+    }
+    if ( !Ntl_ManInsertTest( p ) )
+    {
+        printf( "Abc_NtkDarTestBlif(): Tranformation of the netlist has failed.\n" );
+        return;
+    }
+    sprintf( Buffer, "%s_.blif", p->pName );
+    Ioa_WriteBlif( p, Buffer );
+    Ntl_ManFree( p );
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////

src/base/abci/abcRefactor.c

@@ -84,6 +84,7 @@ static Dec_Graph_t *  Abc_NodeRefactor( Abc_ManRef_t * p, Abc_Obj_t * pNode, Vec
 ***********************************************************************/
 int Abc_NtkRefactor( Abc_Ntk_t * pNtk, int nNodeSizeMax, int nConeSizeMax, bool fUpdateLevel, bool fUseZeros, bool fUseDcs, bool fVerbose )
 {
+    extern void           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain );
     ProgressBar * pProgress;
     Abc_ManRef_t * pManRef;
     Abc_ManCut_t * pManCut;
@@ -183,6 +184,7 @@ pManRef->timeTotal = clock() - clkStart;
 ***********************************************************************/
 Dec_Graph_t * Abc_NodeRefactor( Abc_ManRef_t * p, Abc_Obj_t * pNode, Vec_Ptr_t * vFanins, bool fUpdateLevel, bool fUseZeros, bool fUseDcs, bool fVerbose )
 {
+    extern int            Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMax, int LevelMax );
     int fVeryVerbose = 0;
     Abc_Obj_t * pFanin;
     Dec_Graph_t * pFForm;

src/base/abci/abcRestruct.c

@@ -96,6 +96,7 @@ static void Abc_NtkManRstPrintStats( Abc_ManRst_t * p );
 ***********************************************************************/
 int Abc_NtkRestructure( Abc_Ntk_t * pNtk, int nCutMax, bool fUpdateLevel, bool fUseZeros, bool fVerbose )
 {
+    extern void           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain );
     ProgressBar * pProgress;
     Abc_ManRst_t * pManRst;
     Cut_Man_t * pManCut;

src/base/abci/abcResub.c

@@ -139,6 +139,7 @@ extern int s_ResubTime;
 ***********************************************************************/
 int Abc_NtkResubstitute( Abc_Ntk_t * pNtk, int nCutMax, int nStepsMax, int nLevelsOdc, bool fUpdateLevel, bool fVerbose, bool fVeryVerbose )
 {
+    extern void           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain );
     ProgressBar * pProgress;
     Abc_ManRes_t * pManRes;
     Abc_ManCut_t * pManCut;

src/base/abci/abcRewrite.c

@@ -57,6 +57,7 @@ extern void  Abc_PlaceUpdate( Vec_Ptr_t * vAddedCells, Vec_Ptr_t * vUpdatedNets
 ***********************************************************************/
 int Abc_NtkRewrite( Abc_Ntk_t * pNtk, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose, int fPlaceEnable )
 {
+    extern void           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain );
     ProgressBar * pProgress;
     Cut_Man_t * pManCut;
     Rwr_Man_t * pManRwr;

src/base/seq/seqRetCore.c

@@ -264,6 +264,7 @@ Abc_Ntk_t * Seq_NtkRetimeDerive( Abc_Ntk_t * pNtk, int fVerbose )
 ***********************************************************************/
 Abc_Obj_t * Seq_NodeRetimeDerive( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pRoot, char * pSop, Vec_Ptr_t * vFanins )
 {
+    extern Abc_Obj_t *    Dec_GraphToNetworkNoStrash( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph );
     Dec_Graph_t * pFForm;
     Dec_Node_t * pNode;
     Abc_Obj_t * pResult, * pFanin, * pMirror;

src/map/fpga/fpgaInt.h

@@ -184,8 +184,8 @@ struct Fpga_NodeStruct_t_
     Fpga_Node_t *       pLevel;        // the next node in the linked list by level
     int                 Num;           // the unique number of this node
     int                 NumA;          // the unique number of this node
-    short               Num2;          // the temporary number of this node
-    short               nRefs;         // the number of references (fanouts) of the given node
+    int                 Num2;          // the temporary number of this node
+    int                 nRefs;         // the number of references (fanouts) of the given node
     unsigned            fMark0 : 1;    // the mark used for traversals
     unsigned            fMark1 : 1;    // the mark used for traversals
     unsigned            fInv   : 1;    // the complemented attribute for the equivalent nodes

src/opt/dec/dec.h

@@ -103,10 +103,6 @@ struct Dec_Man_t_
 ////////////////////////////////////////////////////////////////////////
 
 /*=== decAbc.c ========================================================*/
-extern Abc_Obj_t *    Dec_GraphToNetwork( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph );
-extern Abc_Obj_t *    Dec_GraphToNetworkNoStrash( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph );
-extern int            Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMax, int LevelMax );
-extern void           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain );
 /*=== decFactor.c ========================================================*/
 extern Dec_Graph_t *  Dec_Factor( char * pSop );
 /*=== decMan.c ========================================================*/
@@ -115,7 +111,6 @@ extern void           Dec_ManStop( Dec_Man_t * p );
 /*=== decPrint.c ========================================================*/
 extern void           Dec_GraphPrint( FILE * pFile, Dec_Graph_t * pGraph, char * pNamesIn[], char * pNameOut );
 /*=== decUtil.c ========================================================*/
-extern DdNode *       Dec_GraphDeriveBdd( DdManager * dd, Dec_Graph_t * pGraph );
 extern unsigned       Dec_GraphDeriveTruth( Dec_Graph_t * pGraph );
 
 ////////////////////////////////////////////////////////////////////////
@@ -317,7 +312,7 @@ static inline void Dec_GraphFree( Dec_Graph_t * pGraph )
   SeeAlso     []
 
 ***********************************************************************/
-static inline bool Dec_GraphIsConst( Dec_Graph_t * pGraph )   
+static inline int Dec_GraphIsConst( Dec_Graph_t * pGraph )   
 {
     return pGraph->fConst;
 }
@@ -333,7 +328,7 @@ static inline bool Dec_GraphIsConst( Dec_Graph_t * pGraph )
   SeeAlso     []
 
 ***********************************************************************/
-static inline bool Dec_GraphIsConst0( Dec_Graph_t * pGraph )   
+static inline int Dec_GraphIsConst0( Dec_Graph_t * pGraph )   
 {
     return pGraph->fConst && pGraph->eRoot.fCompl;
 }
@@ -349,7 +344,7 @@ static inline bool Dec_GraphIsConst0( Dec_Graph_t * pGraph )
   SeeAlso     []
 
 ***********************************************************************/
-static inline bool Dec_GraphIsConst1( Dec_Graph_t * pGraph )   
+static inline int Dec_GraphIsConst1( Dec_Graph_t * pGraph )   
 {
     return pGraph->fConst && !pGraph->eRoot.fCompl;
 }
@@ -365,7 +360,7 @@ static inline bool Dec_GraphIsConst1( Dec_Graph_t * pGraph )
   SeeAlso     []
 
 ***********************************************************************/
-static inline bool Dec_GraphIsComplement( Dec_Graph_t * pGraph )   
+static inline int Dec_GraphIsComplement( Dec_Graph_t * pGraph )   
 {
     return pGraph->eRoot.fCompl;
 }
@@ -478,7 +473,7 @@ static inline int Dec_GraphNodeInt( Dec_Graph_t * pGraph, Dec_Node_t * pNode )
   SeeAlso     []
 
 ***********************************************************************/
-static inline bool Dec_GraphIsVar( Dec_Graph_t * pGraph )   
+static inline int Dec_GraphIsVar( Dec_Graph_t * pGraph )   
 {
     return pGraph->eRoot.Node < (unsigned)pGraph->nLeaves;
 }
@@ -494,7 +489,7 @@ static inline bool Dec_GraphIsVar( Dec_Graph_t * pGraph )
   SeeAlso     []
 
 ***********************************************************************/
-static inline bool Dec_GraphNodeIsVar( Dec_Graph_t * pGraph, Dec_Node_t * pNode )   
+static inline int Dec_GraphNodeIsVar( Dec_Graph_t * pGraph, Dec_Node_t * pNode )   
 {
     return Dec_GraphNodeInt(pGraph,pNode) < pGraph->nLeaves;
 }

src/opt/dec/decAbc.c

@@ -189,6 +189,7 @@ int Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMa
 ***********************************************************************/
 void Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain )
 {
+    extern Abc_Obj_t *    Dec_GraphToNetwork( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph );
     Abc_Obj_t * pRootNew;
     Abc_Ntk_t * pNtk = pRoot->pNtk;
     int nNodesNew, nNodesOld;

src/opt/dec/decFactor.c

@@ -364,6 +364,7 @@ Mvc_Cover_t * Dec_ConvertSopToMvc( char * pSop )
 ***********************************************************************/
 int Dec_FactorVerify( char * pSop, Dec_Graph_t * pFForm )
 {
+    extern DdNode *       Dec_GraphDeriveBdd( DdManager * dd, Dec_Graph_t * pGraph );
     DdManager * dd = Abc_FrameReadManDd();
     DdNode * bFunc1, * bFunc2;
     int RetValue;

src/opt/rwr/rwrEva.c

@@ -245,6 +245,7 @@ p->timeRes += clock() - clk;
 ***********************************************************************/
 Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCut, Vec_Ptr_t * vFaninsCur, int nNodesSaved, int LevelMax, int * pGainBest, int fPlaceEnable )
 {
+    extern int            Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMax, int LevelMax );
     Vec_Ptr_t * vSubgraphs;
     Dec_Graph_t * pGraphBest, * pGraphCur;
     Rwr_Node_t * pNode, * pFanin;