Version abc80130_2

1 files changed, 190 insertions, 0 deletions

diff --git a/src/base/abci/abcFpgaFast.c b/src/base/abci/abcFpgaFast.c
new file mode 100644
index 00000000..356b855e
--- /dev/null
+++ b/src/base/abci/abcFpgaFast.c
@@ -0,0 +1,190 @@
+/**CFile****************************************************************
+
+  FileName    [abcFpgaFast.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Network and node package.]
+
+  Synopsis    [Fast FPGA mapper.]
+
+  Author      [Sungmin Cho]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: abcFpgaFast.c,v 1.00 2006/09/02 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "abc.h"
+#include "ivy.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+extern Ivy_Man_t * Abc_NtkIvyBefore( Abc_Ntk_t * pNtk, int fSeq, int fUseDc );
+
+static Abc_Ntk_t * Ivy_ManFpgaToAbc( Abc_Ntk_t * pNtk, Ivy_Man_t * pMan );
+static Abc_Obj_t * Ivy_ManToAbcFast_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes );
+
+static inline void        Abc_ObjSetIvy2Abc( Ivy_Man_t * p, int IvyId, Abc_Obj_t * pObjAbc ) {  assert(Vec_PtrEntry(p->pCopy, IvyId) == NULL); assert(!Abc_ObjIsComplement(pObjAbc)); Vec_PtrWriteEntry( p->pCopy, IvyId, pObjAbc );  }
+static inline Abc_Obj_t * Abc_ObjGetIvy2Abc( Ivy_Man_t * p, int IvyId )                      {  return Vec_PtrEntry( p->pCopy, IvyId );         }
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Performs fast FPGA mapping of the network.]
+
+  Description [Takes the AIG to be mapped, the LUT size, and verbosity
+  flag. Produces the new network by fast FPGA mapping of the current 
+  network. If the current network in ABC in not an AIG, the user should 
+  run command "strash" to make sure that the current network into an AIG 
+  before calling this procedure.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkFpgaFast( Abc_Ntk_t * pNtk, int nLutSize, int fRecovery, int fVerbose )
+{
+    Ivy_Man_t * pMan;
+    Abc_Ntk_t * pNtkNew;
+    // make sure the network is an AIG
+    assert( Abc_NtkIsStrash(pNtk) );
+    // convert the network into the AIG
+    pMan = Abc_NtkIvyBefore( pNtk, 0, 0 );
+    // perform fast FPGA mapping
+    Ivy_FastMapPerform( pMan, nLutSize, fRecovery, fVerbose );
+    // convert back into the ABC network
+    pNtkNew = Ivy_ManFpgaToAbc( pNtk, pMan );
+    Ivy_FastMapStop( pMan );
+    Ivy_ManStop( pMan );  
+    // make sure that the final network passes the test
+    if ( pNtkNew != NULL && !Abc_NtkCheck( pNtkNew ) )
+    {
+        printf( "Abc_NtkFastMap: The network check has failed.\n" );
+        Abc_NtkDelete( pNtkNew );
+        return NULL;
+    }
+    return pNtkNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Constructs the ABC network after mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Ivy_ManFpgaToAbc( Abc_Ntk_t * pNtk, Ivy_Man_t * pMan )
+{
+    Abc_Ntk_t * pNtkNew;
+    Abc_Obj_t * pObjAbc, * pObj;
+    Ivy_Obj_t * pObjIvy;
+    Vec_Int_t * vNodes;
+    int i;
+    // start mapping from Ivy into Abc
+    pMan->pCopy = Vec_PtrStart( Ivy_ManObjIdMax(pMan) + 1 );
+    // start the new ABC network
+    pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_AIG );
+    // transfer the pointers to the basic nodes
+    Abc_ObjSetIvy2Abc( pMan, Ivy_ManConst1(pMan)->Id, Abc_NtkCreateNodeConst1(pNtkNew) );
+    Abc_NtkForEachCi( pNtkNew, pObjAbc, i )
+        Abc_ObjSetIvy2Abc( pMan, Ivy_ManPi(pMan, i)->Id, pObjAbc ); 
+    // recursively construct the network
+    vNodes = Vec_IntAlloc( 100 );
+    Ivy_ManForEachPo( pMan, pObjIvy, i )
+    {
+        // get the new ABC node corresponding to the old fanin of the PO in IVY
+        pObjAbc = Ivy_ManToAbcFast_rec( pNtkNew, pMan, Ivy_ObjFanin0(pObjIvy), vNodes );
+        // consider the case of complemented fanin of the PO
+        if ( Ivy_ObjFaninC0(pObjIvy) ) // complement
+        {
+            if ( Abc_ObjIsCi(pObjAbc) )
+                pObjAbc = Abc_NtkCreateNodeInv( pNtkNew, pObjAbc );
+            else
+            {
+                // clone the node
+                pObj = Abc_NtkCloneObj( pObjAbc );
+                // set complemented functions
+                pObj->pData = Hop_Not( pObjAbc->pData );
+                // return the new node
+                pObjAbc = pObj;
+            }
+        }
+        Abc_ObjAddFanin( Abc_NtkCo(pNtkNew, i), pObjAbc );
+    }
+    Vec_IntFree( vNodes );
+    Vec_PtrFree( pMan->pCopy ); 
+    pMan->pCopy = NULL;
+    // remove dangling nodes
+    Abc_NtkCleanup( pNtkNew, 0 );
+    // fix CIs feeding directly into COs
+    Abc_NtkLogicMakeSimpleCos( pNtkNew, 0 );
+    return pNtkNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Recursively construct the new node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Obj_t * Ivy_ManToAbcFast_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes )
+{
+    Vec_Int_t Supp, * vSupp = &Supp;
+    Abc_Obj_t * pObjAbc, * pFaninAbc;
+    Ivy_Obj_t * pNodeIvy;
+    int i, Entry;
+    // skip the node if it is a constant or already processed
+    pObjAbc = Abc_ObjGetIvy2Abc( pMan, pObjIvy->Id );
+    if ( pObjAbc )
+        return pObjAbc;
+    assert( Ivy_ObjIsAnd(pObjIvy) || Ivy_ObjIsExor(pObjIvy) );
+    // get the support of K-LUT
+    Ivy_FastMapReadSupp( pMan, pObjIvy, vSupp );
+    // create new ABC node and its fanins
+    pObjAbc = Abc_NtkCreateNode( pNtkNew );
+    Vec_IntForEachEntry( vSupp, Entry, i )
+    {
+        pFaninAbc = Ivy_ManToAbcFast_rec( pNtkNew, pMan, Ivy_ManObj(pMan, Entry), vNodes );
+        Abc_ObjAddFanin( pObjAbc, pFaninAbc );
+    }
+    // collect the nodes used in the cut
+    Ivy_ManCollectCut( pMan, pObjIvy, vSupp, vNodes );
+    // create the local function
+    Ivy_ManForEachNodeVec( pMan, vNodes, pNodeIvy, i )
+    {
+        if ( i < Vec_IntSize(vSupp) )
+            pNodeIvy->pEquiv = (Ivy_Obj_t *)Hop_IthVar( pNtkNew->pManFunc, i );
+        else
+            pNodeIvy->pEquiv = (Ivy_Obj_t *)Hop_And( pNtkNew->pManFunc, (Hop_Obj_t *)Ivy_ObjChild0Equiv(pNodeIvy), (Hop_Obj_t *)Ivy_ObjChild1Equiv(pNodeIvy) );
+    }
+    // set the local function
+    pObjAbc->pData = (Abc_Obj_t *)pObjIvy->pEquiv;
+    // set the node
+    Abc_ObjSetIvy2Abc( pMan, pObjIvy->Id, pObjAbc ); 
+    return pObjAbc;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+