Version abc61102

author: Alan Mishchenko <alanmi@berkeley.edu> 2006-11-02 08:01:00 -0800
committer: Alan Mishchenko <alanmi@berkeley.edu> 2006-11-02 08:01:00 -0800
commit: faf1265bb82f934cc14b6106ccce89e37203efbd (patch)
tree: f6d69ce4adca5d7e1fdccd3e9848220d6744405d /src/opt
parent: 73bb7932f7edad95086d67a795444537c438309e (diff)
download: abc-faf1265bb82f934cc14b6106ccce89e37203efbd.tar.gz
abc-faf1265bb82f934cc14b6106ccce89e37203efbd.tar.bz2
abc-faf1265bb82f934cc14b6106ccce89e37203efbd.zip
11 files changed, 1525 insertions, 4 deletions
diff --git a/src/opt/ret/module.make b/src/opt/ret/module.make
new file mode 100644
index 00000000..9ac0bf1f
--- /dev/null
+++ b/src/opt/ret/module.make
@@ -0,0 +1,8 @@
+SRC +=  src/opt/dec/retArea.c \
+        src/opt/dec/retBwd.c \
+        src/opt/dec/retCore.c \
+        src/opt/dec/retDelay.c \
+        src/opt/dec/retFlow.c \
+        src/opt/dec/retFwd.c \
+        src/opt/dec/retInit.c
+
diff --git a/src/opt/ret/retArea.c b/src/opt/ret/retArea.c
new file mode 100644
index 00000000..7f93b87b
--- /dev/null
+++ b/src/opt/ret/retArea.c
@@ -0,0 +1,593 @@
+/**CFile****************************************************************
+
+  FileName    [retArea.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    [Min-area retiming.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retArea.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+static int         Abc_NtkRetimeMinAreaFwd( Abc_Ntk_t * pNtk, int fVerbose );
+static Abc_Ntk_t * Abc_NtkRetimeMinAreaBwd( Abc_Ntk_t * pNtk, int fVerbose );
+static void        Abc_NtkRetimeMinAreaPrepare( Abc_Ntk_t * pNtk, int fForward );
+static Vec_Ptr_t * Abc_NtkRetimeMinAreaAddBuffers( Abc_Ntk_t * pNtk );
+static void        Abc_NtkRetimeMinAreaRemoveBuffers( Abc_Ntk_t * pNtk, Vec_Ptr_t * vBuffers );
+static void        Abc_NtkRetimeMinAreaInitValue( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut );
+static Abc_Ntk_t * Abc_NtkRetimeMinAreaConstructNtk( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut );
+static void        Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fForward );
+
+extern Abc_Ntk_t * Abc_NtkAttachBottom( Abc_Ntk_t * pNtkTop, Abc_Ntk_t * pNtkBottom );
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Performs min-area retiming.]
+
+  Description [Returns the number of latches reduced.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetimeMinArea( Abc_Ntk_t * pNtk, int fVerbose )
+{
+    Abc_Ntk_t * pNtkTotal = NULL, * pNtkBottom, * pNtkMiter;
+    Vec_Int_t * vValues;
+    int nLatches = Abc_NtkLatchNum(pNtk);
+    // there should not be black boxes
+    assert( Abc_NtkIsSopLogic(pNtk) );
+    assert( Abc_NtkLatchNum(pNtk) == Vec_PtrSize(pNtk->vBoxes) );
+    // reorder CI/CO/latch inputs
+    Abc_NtkOrderCisCos( pNtk );
+    // perform forward retiming
+    vValues = Abc_NtkCollectLatchValues( pNtk );
+//    Abc_NtkRetimeMinAreaFwd( pNtk, fVerbose );
+    pNtkTotal = Abc_NtkRetimeMinAreaBwd( pNtk, fVerbose );
+
+//    while ( Abc_NtkRetimeMinAreaFwd( pNtk, fVerbose ) );
+    // perform backward retiming
+//    while ( pNtkBottom = Abc_NtkRetimeMinAreaBwd( pNtk, fVerbose ) )
+//        pNtkTotal = Abc_NtkAttachBottom( pNtkTotal, pNtkBottom );  
+    // compute initial values
+    if ( pNtkTotal )
+    {
+        // convert the target network to AIG
+        Abc_NtkLogicToAig( pNtkTotal );
+        // get the miter
+        pNtkMiter = Abc_NtkCreateTarget( pNtkTotal, pNtkTotal->vCos, vValues );
+        Abc_NtkDelete( pNtkTotal );
+        // get the initial values
+        Abc_NtkRetimeInitialValues( pNtk, pNtkMiter, fVerbose );
+        Abc_NtkDelete( pNtkMiter );
+    }
+    Vec_IntFree( vValues );
+    // fix the COs
+    Abc_NtkLogicMakeSimpleCos( pNtk, 0 );
+    // check for correctness
+    if ( !Abc_NtkCheck( pNtk ) )
+        fprintf( stdout, "Abc_NtkRetimeMinArea(): Network check has failed.\n" );
+    // return the number of latches saved
+    return nLatches - Abc_NtkLatchNum(pNtk);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs min-area retiming forward.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetimeMinAreaFwd( Abc_Ntk_t * pNtk, int fVerbose )
+{
+    Vec_Ptr_t * vBuffers, * vMinCut;
+    int nLatches = Abc_NtkLatchNum(pNtk);
+    // mark current latches and TFO(PIs)
+    Abc_NtkRetimeMinAreaPrepare( pNtk, 1 );
+    // add buffers on edges feeding into the marked nodes
+    vBuffers = Abc_NtkRetimeMinAreaAddBuffers( pNtk );
+    // run the maximum forward flow
+    vMinCut = Abc_NtkMaxFlow( pNtk, 1, fVerbose );
+    assert( Vec_PtrSize(vMinCut) <= Abc_NtkLatchNum(pNtk) );
+    // create new latch boundary if there is improvement
+    if ( Vec_PtrSize(vMinCut) < Abc_NtkLatchNum(pNtk) )
+    {
+        Abc_NtkRetimeMinAreaInitValue( pNtk, vMinCut );
+        Abc_NtkRetimeMinAreaUpdateLatches( pNtk, vMinCut, 1 );
+    }
+    // clean up
+    Abc_NtkRetimeMinAreaRemoveBuffers( pNtk, vBuffers );
+    Vec_PtrFree( vMinCut );
+    Abc_NtkCleanMarkA( pNtk );
+    return nLatches - Abc_NtkLatchNum(pNtk);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs min-area retiming backward.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkRetimeMinAreaBwd( Abc_Ntk_t * pNtk, int fVerbose )
+{
+    Abc_Ntk_t * pNtkNew = NULL;
+    Vec_Ptr_t * vMinCut;
+    int nLatches = Abc_NtkLatchNum(pNtk);
+    // mark current latches and TFI(POs)
+    Abc_NtkRetimeMinAreaPrepare( pNtk, 0 );
+    // run the maximum forward flow
+    vMinCut = Abc_NtkMaxFlow( pNtk, 0, fVerbose );
+    assert( Vec_PtrSize(vMinCut) <= Abc_NtkLatchNum(pNtk) );
+    // create new latch boundary if there is improvement
+    if ( Vec_PtrSize(vMinCut) < Abc_NtkLatchNum(pNtk) )
+    {
+        pNtkNew = Abc_NtkRetimeMinAreaConstructNtk( pNtk, vMinCut );
+        Abc_NtkRetimeMinAreaUpdateLatches( pNtk, vMinCut, 0 );
+    }
+    // clean up
+    Vec_PtrFree( vMinCut );
+    Abc_NtkCleanMarkA( pNtk );
+    return pNtkNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Marks the cone with MarkA.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMarkCone_rec( Abc_Obj_t * pObj, int fForward )
+{
+    Abc_Obj_t * pNext;
+    int i;
+    if ( pObj->fMarkA )
+        return;
+    pObj->fMarkA = 1;
+    if ( fForward )
+    {
+        Abc_ObjForEachFanout( pObj, pNext, i )
+            Abc_NtkMarkCone_rec( pNext, fForward );
+    }
+    else
+    {
+        Abc_ObjForEachFanin( pObj, pNext, i )
+            Abc_NtkMarkCone_rec( pNext, fForward );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prepares the network for running MaxFlow.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkRetimeMinAreaPrepare( Abc_Ntk_t * pNtk, int fForward )
+{
+    Abc_Obj_t * pObj;
+    int i;
+    if ( fForward )
+    {
+        // mark the frontier
+        Abc_NtkForEachPo( pNtk, pObj, i )
+            pObj->fMarkA = 1;
+        Abc_NtkForEachLatch( pNtk, pObj, i )
+        {
+            pObj->fMarkA = 1;
+            Abc_ObjFanin0(pObj)->fMarkA = 1;
+        }
+        // mark the nodes reachable from the POs
+        Abc_NtkForEachPi( pNtk, pObj, i )
+            Abc_NtkMarkCone_rec( pObj, fForward );
+    }
+    else
+    {
+        // mark the frontier
+        Abc_NtkForEachPi( pNtk, pObj, i )
+            pObj->fMarkA = 1;
+        Abc_NtkForEachLatch( pNtk, pObj, i )
+        {
+            pObj->fMarkA = 1;
+            Abc_ObjFanout0(pObj)->fMarkA = 1;
+        }
+        // mark the nodes reachable from the POs
+        Abc_NtkForEachPo( pNtk, pObj, i )
+            Abc_NtkMarkCone_rec( pObj, fForward );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Add extra buffers.]
+
+  Description [This is needed to make sure that forward retiming 
+  works correctly. This has to do with the nodes in the TFO cone
+  of the PIs having multiple incoming edges.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Abc_NtkRetimeMinAreaAddBuffers( Abc_Ntk_t * pNtk )
+{
+    Vec_Ptr_t * vFeeds, * vFanouts;
+    Abc_Obj_t * pObj, * pFanin, * pFanout, * pBuffer;
+    int i, k;
+    // collect all nodes that are feeding into the marked nodes
+    Abc_NtkIncrementTravId(pNtk);
+    vFeeds = Vec_PtrAlloc( 100 );
+    Abc_NtkForEachObj( pNtk, pObj, i )
+    {
+        if ( !pObj->fMarkA )
+            continue;
+        Abc_ObjForEachFanin( pObj, pFanin, k )
+            if ( !pFanin->fMarkA && !Abc_NodeIsTravIdCurrent(pFanin) )
+            {
+                Abc_NodeSetTravIdCurrent( pFanin );
+                Vec_PtrPush( vFeeds, pFanin );
+            }
+    }
+    // add buffers for each such node
+    vFanouts = Vec_PtrAlloc( 100 );
+    Vec_PtrForEachEntry( vFeeds, pObj, i )
+    {
+        // create and remember the buffers
+        pBuffer = Abc_NtkCreateNodeBuf( pNtk, pObj );
+        Vec_PtrWriteEntry( vFeeds, i, pBuffer );
+        // patch the fanin of each marked fanout to point to the buffer
+        Abc_NodeCollectFanouts( pObj, vFanouts );
+        Vec_PtrForEachEntry( vFanouts, pFanout, k )
+            if ( pFanout->fMarkA )
+                Abc_ObjPatchFanin( pFanout, pObj, pBuffer );
+    }
+    Vec_PtrFree( vFanouts );
+    // mark the new buffers
+    Vec_PtrForEachEntry( vFeeds, pObj, i )
+        pObj->fMarkA = 1;
+    return vFeeds;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes extra buffers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkRetimeMinAreaRemoveBuffers( Abc_Ntk_t * pNtk, Vec_Ptr_t * vBuffers )
+{
+    Abc_Obj_t * pObj;
+    int i;
+    Vec_PtrForEachEntry( vBuffers, pObj, i )
+    {
+        Abc_ObjTransferFanout( pObj, Abc_ObjFanin0(pObj) );
+        Abc_NtkDeleteObj( pObj );
+    }
+    Vec_PtrFree( vBuffers );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes the results of simulating one node.]
+
+  Description [Assumes that fanins have pCopy set to the input values.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_ObjSopSimulate( Abc_Obj_t * pObj )
+{
+    char * pCube, * pSop = pObj->pData;
+    int nVars, Value, v, ResOr, ResAnd, ResVar;
+    assert( pSop && !Abc_SopIsExorType(pSop) );
+    // simulate the SOP of the node
+    ResOr = 0;
+    nVars = Abc_SopGetVarNum(pSop);
+    Abc_SopForEachCube( pSop, nVars, pCube )
+    {
+        ResAnd = 1;
+        Abc_CubeForEachVar( pCube, Value, v )
+        {
+            if ( Value == '0' )
+                ResVar = 1 ^ ((int)Abc_ObjFanin(pObj, v)->pCopy);
+            else if ( Value == '1' )
+                ResVar = (int)Abc_ObjFanin(pObj, v)->pCopy;
+            else
+                continue;
+            ResAnd &= ResVar;
+        }
+        ResOr |= ResAnd;
+    }
+    // complement the result if necessary
+    if ( !Abc_SopGetPhase(pSop) )
+        ResOr ^= 1;
+    return ResOr;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute initial values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetimeMinAreaInitValue_rec( Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pFanin;
+    int i;
+    // skip visited nodes
+    if ( Abc_NodeIsTravIdCurrent(pObj) )
+        return (int)pObj->pCopy;
+    Abc_NodeSetTravIdCurrent(pObj);
+    // consider the case of a latch output
+    if ( Abc_ObjIsBi(pObj) )
+    {
+        assert( Abc_ObjIsLatch(Abc_ObjFanin0(pObj)) );
+        pObj->pCopy = (void *)Abc_NtkRetimeMinAreaInitValue_rec( Abc_ObjFanin0(pObj) );
+        return (int)pObj->pCopy;
+    }
+    assert( Abc_ObjIsNode(pObj) );
+    // visit the fanins
+    Abc_ObjForEachFanin( pObj, pFanin, i )
+        Abc_NtkRetimeMinAreaInitValue_rec( pFanin );
+    // compute the value of the node
+    pObj->pCopy = (void *)Abc_ObjSopSimulate(pObj);
+    return (int)pObj->pCopy;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute initial values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkRetimeMinAreaInitValue( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut )
+{
+    Abc_Obj_t * pObj;
+    int i;
+    // transfer initial values to pCopy and mark the latches
+    Abc_NtkIncrementTravId(pNtk);
+    Abc_NtkForEachLatch( pNtk, pObj, i )
+    {
+        pObj->pCopy = (void *)Abc_LatchIsInit1(pObj);
+        Abc_NodeSetTravIdCurrent( pObj );
+    }
+    // propagate initial values
+    Vec_PtrForEachEntry( vMinCut, pObj, i )
+        Abc_NtkRetimeMinAreaInitValue_rec( pObj );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs min-area retiming backward.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Obj_t * Abc_NtkRetimeMinAreaConstructNtk_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pFanin;
+    int i;
+    // skip visited nodes
+    if ( Abc_NodeIsTravIdCurrent(pObj) )
+        return pObj->pCopy;
+    Abc_NodeSetTravIdCurrent(pObj);
+    // consider the case of a latch output
+    if ( Abc_ObjIsBo(pObj) )
+        return Abc_NtkRetimeMinAreaConstructNtk_rec( pNtkNew, Abc_ObjFanin0(pObj) );
+    assert( Abc_ObjIsNode(pObj) );
+    // visit the fanins
+    Abc_ObjForEachFanin( pObj, pFanin, i )
+        Abc_NtkRetimeMinAreaConstructNtk_rec( pNtkNew, pFanin );
+    // compute the value of the node
+    Abc_NtkDupObj( pNtkNew, pObj, 0 );
+    Abc_ObjForEachFanin( pObj, pFanin, i )
+        Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
+    return pObj->pCopy;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the network from computing initial state.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkRetimeMinAreaConstructNtk( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut )
+{
+    Abc_Ntk_t * pNtkNew;
+    Abc_Obj_t * pObj, * pObjNew;
+    int i;
+    // create new network
+    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 );
+    // set mapping of new latches into the PIs of the network
+    Abc_NtkIncrementTravId(pNtk);
+    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    {
+        pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
+        Abc_NodeSetTravIdCurrent( pObj );
+    }
+    // construct the network recursively
+    Abc_NtkForEachLatch( pNtk, pObj, i )
+    {
+        pObjNew = Abc_NtkRetimeMinAreaConstructNtk_rec( pNtkNew, Abc_ObjFanin0(pObj) );
+        Abc_ObjAddFanin( Abc_NtkCreatePo(pNtkNew), pObjNew );
+    }
+    // assign dummy node names
+    Abc_NtkAddDummyPiNames( pNtkNew );
+    Abc_NtkAddDummyPoNames( pNtkNew );
+    if ( !Abc_NtkCheck( pNtkNew ) )
+        fprintf( stdout, "Abc_NtkRetimeMinAreaConstructNtk(): Network check has failed.\n" );
+    return pNtkNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Updates the network after backward retiming.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fForward )
+{
+    Vec_Ptr_t * vCis, * vCos, * vBoxes, * vBoxesNew, * vFanouts;
+    Abc_Obj_t * pObj, * pLatch, * pLatchIn, * pLatchOut, * pFanout;
+    int i, k;
+    // create new latches
+    Vec_PtrShrink( pNtk->vCis, Abc_NtkCiNum(pNtk) - Abc_NtkLatchNum(pNtk) );
+    Vec_PtrShrink( pNtk->vCos, Abc_NtkCoNum(pNtk) - Abc_NtkLatchNum(pNtk) );
+    vCis   = pNtk->vCis;   pNtk->vCis   = NULL;  
+    vCos   = pNtk->vCos;   pNtk->vCos   = NULL;  
+    vBoxes = pNtk->vBoxes; pNtk->vBoxes = NULL; 
+    // transfer boxes
+    vBoxesNew = Vec_PtrAlloc(100);
+    Vec_PtrForEachEntry( vBoxes, pObj, i )
+        if ( !Abc_ObjIsLatch(pObj) )
+            Vec_PtrPush( vBoxesNew, pObj );
+    // create or reuse latches
+    Abc_NtkIncrementTravId(pNtk);
+    vFanouts = Vec_PtrAlloc( 100 );
+    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    {
+        if ( Abc_ObjIsCi(pObj) && fForward )
+        {
+            pLatchOut = pObj;
+            pLatch    = Abc_ObjFanin0(pLatchOut);
+            pLatchIn  = Abc_ObjFanin0(pLatch);
+            assert( Abc_ObjIsBi(pLatchOut) && Abc_ObjIsLatch(pLatch) && Abc_ObjIsBo(pLatchIn) );
+            // mark the latch as reused
+            Abc_NodeSetTravIdCurrent( pLatch );
+        }
+        else if ( Abc_ObjIsCo(pObj) && !fForward )
+        {
+            pLatchIn  = pObj;
+            pLatch    = Abc_ObjFanout0(pLatchIn);
+            pLatchOut = Abc_ObjFanout0(pLatch);
+            assert( Abc_ObjIsBi(pLatchOut) && Abc_ObjIsLatch(pLatch) && Abc_ObjIsBo(pLatchIn) );
+            // mark the latch as reused
+            Abc_NodeSetTravIdCurrent( pLatch );
+        }
+        else
+        {
+            pLatchOut = Abc_NtkCreateBi(pNtk);
+            pLatch    = Abc_NtkCreateLatch(pNtk);
+            pLatchIn  = Abc_NtkCreateBo(pNtk);
+            Abc_ObjAssignName( pLatchOut, Abc_ObjName(pLatchOut), NULL );
+            Abc_ObjAssignName( pLatchIn,  Abc_ObjName(pLatchIn), NULL );
+            // connect
+            Abc_ObjAddFanin( pLatchOut, pLatch );
+            Abc_ObjAddFanin( pLatch, pLatchIn );
+            if ( fForward )
+            {
+                Abc_ObjTransferFanout( pObj, pLatchOut );
+                pLatch->pData = (void *)(pObj->pCopy? ABC_INIT_ONE : ABC_INIT_ZERO);
+            }
+            else
+            {
+                // redirect unmarked edges
+                Abc_NodeCollectFanouts( pObj, vFanouts );
+                Vec_PtrForEachEntry( vFanouts, pFanout, k )
+                    if ( !pFanout->fMarkA )
+                        Abc_ObjPatchFanin( pFanout, pObj, pLatchOut );
+            }
+            // connect latch to the node
+            Abc_ObjAddFanin( pLatchIn, pObj );
+        }
+        Vec_PtrPush( vCis, pLatchOut );
+        Vec_PtrPush( vBoxesNew, pLatch );
+        Vec_PtrPush( vCos, pLatchIn );
+    }
+    Vec_PtrFree( vFanouts );
+    // remove useless latches
+    Vec_PtrForEachEntry( vBoxes, pObj, i )
+    {
+        if ( !Abc_ObjIsLatch(pObj) )
+            continue;
+        if ( Abc_NodeIsTravIdCurrent(pObj) )
+            continue;
+        pLatchOut = Abc_ObjFanout0(pObj);
+        pLatch    = pObj;
+        pLatchIn  = Abc_ObjFanin0(pObj);
+        Abc_ObjTransferFanout( pLatchOut, Abc_ObjFanin0(pLatchIn) );
+        Abc_NtkDeleteObj( pLatchOut );
+        Abc_NtkDeleteObj( pObj );
+        Abc_NtkDeleteObj( pLatchIn );
+    }
+    // set the arrays
+    pNtk->vCis = vCis;
+    pNtk->vCos = vCos;
+    pNtk->vBoxes = vBoxesNew;
+    Vec_PtrFree( vBoxes );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retBwd.c b/src/opt/ret/retBwd.c
new file mode 100644
index 00000000..7eefc4e0
--- /dev/null
+++ b/src/opt/ret/retBwd.c
@@ -0,0 +1,65 @@
+/**CFile****************************************************************
+
+  FileName    [retBwd.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    [Most backward retiming.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retBwd.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetimeBackward( Abc_Ntk_t * pNtk, int fVerbose )
+{
+    printf( "Not implemented.\n" );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retCore.c b/src/opt/ret/retCore.c
new file mode 100644
index 00000000..541f5962
--- /dev/null
+++ b/src/opt/ret/retCore.c
@@ -0,0 +1,76 @@
+/**CFile****************************************************************
+
+  FileName    [retCore.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    [The core retiming procedures.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retCore.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Implementation of retiming.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int fVerbose )
+{
+    int RetValue;
+    assert( Mode > 0 && Mode < 6 );
+    // perform forward retiming
+    switch ( Mode )
+    {
+    case 1: // forward 
+        RetValue = Abc_NtkRetimeForward( pNtk, fVerbose );
+        break;
+    case 2: // backward 
+        RetValue = Abc_NtkRetimeBackward( pNtk, fVerbose );
+        break;
+    case 3: // min-area 
+        RetValue = Abc_NtkRetimeMinArea( pNtk, fVerbose );
+        break;
+    case 4: // min-delay
+        RetValue = Abc_NtkRetimeMinDelay( pNtk, fVerbose );
+        break;
+    case 5: // min-area + min-delay
+        RetValue  = Abc_NtkRetimeMinArea( pNtk, fVerbose );
+        RetValue += Abc_NtkRetimeMinDelay( pNtk, fVerbose );
+        break;
+    default:
+        printf( "Unknown retiming option.\n" );
+        break;
+    }
+    return RetValue;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retDelay.c b/src/opt/ret/retDelay.c
new file mode 100644
index 00000000..b7ccc570
--- /dev/null
+++ b/src/opt/ret/retDelay.c
@@ -0,0 +1,65 @@
+/**CFile****************************************************************
+
+  FileName    [retDelay.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    [Incremental retiming for optimum delay.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retDelay.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, int fVerbose )
+{
+    printf( "Not implemented.\n" );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retFlow.c b/src/opt/ret/retFlow.c
new file mode 100644
index 00000000..9b8393f3
--- /dev/null
+++ b/src/opt/ret/retFlow.c
@@ -0,0 +1,462 @@
+/**CFile****************************************************************
+
+  FileName    [retFlow.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Network and node package.]
+
+  Synopsis    [Implementation of maximum flow (min-area retiming).]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retFlow.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+static inline int         Abc_ObjSetPath( Abc_Obj_t * pObj, Abc_Obj_t * pNext ) { pObj->pCopy = pNext; return 1;   }
+static inline Abc_Obj_t * Abc_ObjGetPath( Abc_Obj_t * pObj )                    { return pObj->pCopy;              }
+static inline Abc_Obj_t * Abc_ObjGetFanoutPath( Abc_Obj_t * pObj ) 
+{ 
+    Abc_Obj_t * pFanout;
+    int i;
+    assert( Abc_ObjGetPath(pObj) ); 
+    Abc_ObjForEachFanout( pObj, pFanout, i )
+        if ( Abc_ObjGetPath(pFanout) == pObj )
+            return pFanout;
+    return NULL;
+}
+static inline Abc_Obj_t * Abc_ObjGetFaninPath( Abc_Obj_t * pObj ) 
+{ 
+    Abc_Obj_t * pFanin;
+    int i;
+    assert( Abc_ObjGetPath(pObj) ); 
+    Abc_ObjForEachFanin( pObj, pFanin, i )
+        if ( Abc_ObjGetPath(pFanin) == pObj )
+            return pFanin;
+    return NULL;
+}
+
+static int         Abc_NtkMaxFlowPath( Abc_Ntk_t * pNtk, int * pStart, int fForward );
+static int         Abc_NtkMaxFlowBwdPath_rec( Abc_Obj_t * pObj );
+static int         Abc_NtkMaxFlowFwdPath_rec( Abc_Obj_t * pObj );
+static Vec_Ptr_t * Abc_NtkMaxFlowMinCut( Abc_Ntk_t * pNtk );
+static int         Abc_NtkMaxFlowVerifyCut( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fForward );
+static void        Abc_NtkMaxFlowPrintFlow( Abc_Ntk_t * pNtk, int fForward );
+static void        Abc_NtkMaxFlowPrintCut( Vec_Ptr_t * vMinCut );
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Test-bench for the max-flow computation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMaxFlowTest( Abc_Ntk_t * pNtk )
+{
+    Vec_Ptr_t * vMinCut;
+    Abc_Obj_t * pObj;
+    int i;
+
+    // forward flow
+    Abc_NtkForEachPo( pNtk, pObj, i )
+        pObj->fMarkA = 1;
+    Abc_NtkForEachLatch( pNtk, pObj, i )
+        pObj->fMarkA = Abc_ObjFanin0(pObj)->fMarkA = 1;
+    vMinCut = Abc_NtkMaxFlow( pNtk, 1, 1 );
+    Vec_PtrFree( vMinCut );
+    Abc_NtkCleanMarkA( pNtk );
+
+    // backward flow
+    Abc_NtkForEachPi( pNtk, pObj, i )
+        pObj->fMarkA = 1;
+    Abc_NtkForEachLatch( pNtk, pObj, i )
+        pObj->fMarkA = Abc_ObjFanout0(pObj)->fMarkA = 1;
+    vMinCut = Abc_NtkMaxFlow( pNtk, 0, 1 );
+    Vec_PtrFree( vMinCut );
+    Abc_NtkCleanMarkA( pNtk );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Implementation of max-flow/min-cut computation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Abc_NtkMaxFlow( Abc_Ntk_t * pNtk, int fForward, int fVerbose )
+{
+    Vec_Ptr_t * vMinCut;
+    int Flow, RetValue;
+    int clk = clock();
+    int Start = 0;
+
+    // find the max-flow
+    Abc_NtkCleanCopy( pNtk );
+    for ( Flow = 0; Abc_NtkMaxFlowPath( pNtk, &Start, fForward ); Flow++ );
+//    Abc_NtkMaxFlowPrintFlow( pNtk, fForward );
+
+    // find the min-cut with the smallest volume
+    RetValue = Abc_NtkMaxFlowPath( pNtk, NULL, fForward );
+    assert( RetValue == 0 );
+    vMinCut = Abc_NtkMaxFlowMinCut( pNtk );
+    if ( !Abc_NtkMaxFlowVerifyCut(pNtk, vMinCut, fForward) )
+        printf( "Abc_NtkMaxFlow() error! The computed min-cut is not a cut!\n" );
+
+    // report the results
+    printf( "Latches = %6d. %s max-flow = %6d.  Min-cut = %6d.  ", 
+        Abc_NtkLatchNum(pNtk), fForward? "Forward " : "Backward", Flow, Vec_PtrSize(vMinCut) );
+PRT( "Time", clock() - clk );
+
+//    Abc_NtkMaxFlowPrintCut( vMinCut );
+    return vMinCut;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Finds and augments one path.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkMaxFlowPath( Abc_Ntk_t * pNtk, int * pStart, int fForward )
+{
+    Abc_Obj_t * pLatch;
+    int i, LatchStart = pStart? *pStart : 0;
+    Abc_NtkIncrementTravId(pNtk);
+    Vec_PtrForEachEntryStart( pNtk->vBoxes, pLatch, i, LatchStart )
+    {
+        if ( !Abc_ObjIsLatch(pLatch) )
+            continue;
+        if ( fForward )
+        {
+            assert( !Abc_ObjFanout0(pLatch)->fMarkA );
+            if ( Abc_NtkMaxFlowFwdPath_rec( Abc_ObjFanout0(pLatch) ) )
+            {
+                if ( pStart ) *pStart = i + 1;
+                return 1;
+            }
+        }
+        else
+        {
+            assert( !Abc_ObjFanin0(pLatch)->fMarkA );
+            if ( Abc_NtkMaxFlowBwdPath_rec( Abc_ObjFanin0(pLatch) ) )
+            {
+                if ( pStart ) *pStart = i + 1;
+                return 1;
+            }
+        }
+    }
+    if ( pStart ) *pStart = 0;
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Tries to find an augmenting path originating in this node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkMaxFlowBwdPath_rec( Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pFanout, * pFanin;
+    int i;
+    // skip visited nodes
+    if ( Abc_NodeIsTravIdCurrent(pObj) )
+        return 0;
+    Abc_NodeSetTravIdCurrent(pObj);
+    // process node without flow
+    if ( !Abc_ObjGetPath(pObj) )
+    {
+        // start the path if we reached a terminal node
+        if ( pObj->fMarkA )
+            return Abc_ObjSetPath( pObj, (void *)1 );
+        // explore the fanins
+        Abc_ObjForEachFanin( pObj, pFanin, i )
+            if ( Abc_NtkMaxFlowBwdPath_rec(pFanin) )
+                return Abc_ObjSetPath( pObj, pFanin );
+        return 0;
+    }
+    // pObj has flow - find the fanout with flow
+    pFanout = Abc_ObjGetFanoutPath( pObj );
+    if ( pFanout == NULL )
+        return 0;
+    // go through the fanins of the fanout with flow
+    Abc_ObjForEachFanin( pFanout, pFanin, i )
+        if ( pFanin != pObj && Abc_NtkMaxFlowBwdPath_rec( pFanin ) )
+            return Abc_ObjSetPath( pFanout, pFanin );
+    // try the fanout
+    if ( Abc_NtkMaxFlowBwdPath_rec( pFanout ) )
+        return Abc_ObjSetPath( pFanout, NULL );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Tries to find an augmenting path originating in this node.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkMaxFlowFwdPath_rec( Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pFanout, * pFanin;
+    int i;
+    // skip visited nodes
+    if ( Abc_NodeIsTravIdCurrent(pObj) )
+        return 0;
+    Abc_NodeSetTravIdCurrent(pObj);
+    // process node without flow
+    if ( !Abc_ObjGetPath(pObj) )
+    { 
+        // start the path if we reached a terminal node
+        if ( pObj->fMarkA )
+            return Abc_ObjSetPath( pObj, (void *)1 );
+        // explore the fanins
+        Abc_ObjForEachFanout( pObj, pFanout, i )
+            if ( Abc_NtkMaxFlowFwdPath_rec(pFanout) )
+                return Abc_ObjSetPath( pObj, pFanout );
+        return 0;
+    }
+    // pObj has flow - find the fanout with flow
+    pFanin = Abc_ObjGetFaninPath( pObj );
+    if ( pFanin == NULL )
+        return 0;
+    // go through the fanins of the fanout with flow
+    Abc_ObjForEachFanout( pFanin, pFanout, i )
+        if ( pFanout != pObj && Abc_NtkMaxFlowFwdPath_rec( pFanout ) )
+            return Abc_ObjSetPath( pFanin, pFanout );
+    // try the fanout
+    if ( Abc_NtkMaxFlowFwdPath_rec( pFanin ) )
+        return Abc_ObjSetPath( pFanin, NULL );
+    return 0;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Find one minumum cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Abc_NtkMaxFlowMinCut( Abc_Ntk_t * pNtk )
+{
+    Vec_Ptr_t * vMinCut;
+    Abc_Obj_t * pObj;
+    int i;
+    // collect the cut nodes
+    vMinCut = Vec_PtrAlloc( Abc_NtkLatchNum(pNtk) );
+    Abc_NtkForEachObj( pNtk, pObj, i )
+    {
+        // node without flow is not a cut node
+        if ( !Abc_ObjGetPath(pObj) )
+            continue;
+        // unvisited node is below the cut
+        if ( !Abc_NodeIsTravIdCurrent(pObj) )
+            continue;
+        // add terminal with flow or node whose path is not visited
+        if ( pObj->fMarkA || !Abc_NodeIsTravIdCurrent( Abc_ObjGetPath(pObj) ) )
+            Vec_PtrPush( vMinCut, pObj );
+    }
+    return vMinCut;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Verifies the min-cut is indeed a cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkMaxFlowVerifyCut_rec( Abc_Obj_t * pObj, int fForward )
+{
+    Abc_Obj_t * pNext;
+    int i;
+    // skip visited nodes
+    if ( Abc_NodeIsTravIdCurrent(pObj) )
+        return 1;
+    Abc_NodeSetTravIdCurrent(pObj);
+    // visit the node
+    if ( fForward )
+    {
+        if ( Abc_ObjIsCo(pObj) )
+            return 0;
+        // explore the fanouts
+        Abc_ObjForEachFanout( pObj, pNext, i )
+            if ( !Abc_NtkMaxFlowVerifyCut_rec(pNext, fForward) )
+                return 0;
+    }
+    else
+    {
+        if ( Abc_ObjIsCi(pObj) )
+            return 0;
+        // explore the fanins
+        Abc_ObjForEachFanin( pObj, pNext, i )
+            if ( !Abc_NtkMaxFlowVerifyCut_rec(pNext, fForward) )
+                return 0;
+    }
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Verifies the min-cut is indeed a cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkMaxFlowVerifyCut( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fForward )
+{
+    Abc_Obj_t * pObj;
+    int i;
+    // mark the cut with the current traversal ID
+    Abc_NtkIncrementTravId(pNtk);
+    Vec_PtrForEachEntry( vMinCut, pObj, i )
+        Abc_NodeSetTravIdCurrent( pObj );
+    // search from the latches for a path to the COs/CIs
+    Abc_NtkForEachLatch( pNtk, pObj, i )
+    {
+        if ( fForward )
+        {
+            assert( !Abc_ObjFanout0(pObj)->fMarkA );
+            if ( !Abc_NtkMaxFlowVerifyCut_rec( Abc_ObjFanout0(pObj), fForward ) )
+                return 0;
+        }
+        else
+        {
+            assert( !Abc_ObjFanin0(pObj)->fMarkA );
+            if ( !Abc_NtkMaxFlowVerifyCut_rec( Abc_ObjFanin0(pObj), fForward ) )
+                return 0;
+        }
+    }
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the flows.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMaxFlowPrintFlow( Abc_Ntk_t * pNtk, int fForward )
+{
+    Abc_Obj_t * pLatch, * pNext, * pPrev;
+    int i;
+    if ( fForward )
+    {
+        Vec_PtrForEachEntry( pNtk->vBoxes, pLatch, i )
+        {
+            assert( !Abc_ObjFanout0(pLatch)->fMarkA );
+            if ( Abc_ObjGetPath(Abc_ObjFanout0(pLatch)) == NULL ) // no flow through this latch
+                continue;
+            printf( "Path = " );
+            for ( pNext = Abc_ObjFanout0(pLatch); pNext != (void *)1; pNext = Abc_ObjGetPath(pNext) )
+            {
+                printf( "%s(%d) ", Abc_ObjName(pNext), pNext->Id );
+                pPrev = pNext;
+            }
+            if ( !Abc_ObjIsPo(pPrev) )
+            printf( "%s(%d) ", Abc_ObjName(Abc_ObjFanout0(pPrev)), Abc_ObjFanout0(pPrev)->Id );
+            printf( "\n" );
+        }
+    }
+    else
+    {
+        Vec_PtrForEachEntry( pNtk->vBoxes, pLatch, i )
+        {
+            assert( !Abc_ObjFanin0(pLatch)->fMarkA );
+            if ( Abc_ObjGetPath(Abc_ObjFanin0(pLatch)) == NULL ) // no flow through this latch
+                continue;
+            printf( "Path = " );
+            for ( pNext = Abc_ObjFanin0(pLatch); pNext != (void *)1; pNext = Abc_ObjGetPath(pNext) )
+            {
+                printf( "%s(%d) ", Abc_ObjName(pNext), pNext->Id );
+                pPrev = pNext;
+            }
+            if ( !Abc_ObjIsPi(pPrev) )
+            printf( "%s(%d) ", Abc_ObjName(Abc_ObjFanin0(pPrev)), Abc_ObjFanin0(pPrev)->Id );
+            printf( "\n" );
+        }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Prints the min-cut.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMaxFlowPrintCut( Vec_Ptr_t * vMinCut )
+{
+    Abc_Obj_t * pObj;
+    int i;
+    printf( "Min-cut: " );
+    Vec_PtrForEachEntry( vMinCut, pObj, i )
+        printf( "%d ", pObj->Id );
+    printf( "\n" );
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retFwd.c b/src/opt/ret/retFwd.c
new file mode 100644
index 00000000..c33abc30
--- /dev/null
+++ b/src/opt/ret/retFwd.c
@@ -0,0 +1,65 @@
+/**CFile****************************************************************
+
+  FileName    [retFwd.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    [Most forward retiming.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retFwd.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkRetimeForward( Abc_Ntk_t * pNtk, int fVerbose )
+{
+    printf( "Not implemented.\n" );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retInit.c b/src/opt/ret/retInit.c
new file mode 100644
index 00000000..169d5a63
--- /dev/null
+++ b/src/opt/ret/retInit.c
@@ -0,0 +1,71 @@
+/**CFile****************************************************************
+
+  FileName    [ret_.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: ret_.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Computes initial values of the new latches.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkRetimeInitialValues( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkMiter, int fVerbose )
+{
+    Abc_Obj_t * pLatch;
+    int * pModel, RetValue, clk, i;
+    if ( fVerbose )
+        printf( "The number of ANDs in the AIG = %5d.\n", Abc_NtkNodeNum(pNtkMiter) );
+    // solve the miter
+clk = clock();
+    RetValue = Abc_NtkMiterSat( pNtkMiter, (sint64)500000, (sint64)50000000, 0, 0, NULL, NULL );
+if ( fVerbose && clock() - clk > 100 )
+{
+PRT( "SAT solving time", clock() - clk );
+}
+    // analyze the result
+    if ( RetValue == 1 )
+        printf( "Abc_NtkRetimeInitialValues(): The problem is unsatisfiable. DC latch values are used.\n" );
+    else if ( RetValue == -1 )
+        printf( "Abc_NtkRetimeInitialValues(): The SAT problem timed out. DC latch values are used.\n" );
+    // set the values of the latches
+    pModel = pNtkMiter->pModel;  pNtkMiter->pModel = NULL;
+    Abc_NtkForEachLatch( pNtk, pLatch, i )
+        pLatch->pData = (void *)(pModel? (pModel[i]? ABC_INIT_ONE : ABC_INIT_ZERO) : ABC_INIT_DC);
+    FREE( pModel );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/retInt.h b/src/opt/ret/retInt.h
new file mode 100644
index 00000000..2cb465fa
--- /dev/null
+++ b/src/opt/ret/retInt.h
@@ -0,0 +1,68 @@
+/**CFile****************************************************************
+
+  FileName    [retInt.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    [Internal declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: retInt.h,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef __RET_INT_H__
+#define __RET_INT_H__
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "abc.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    STRUCTURE DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/*=== retArea.c ========================================================*/
+extern int         Abc_NtkRetimeMinArea( Abc_Ntk_t * pNtk, int fVerbose );
+/*=== retBwd.c ========================================================*/
+extern int         Abc_NtkRetimeBackward( Abc_Ntk_t * pNtk, int fVerbose );
+/*=== retCore.c ========================================================*/
+extern int         Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int fVerbose );
+/*=== retDelay.c ========================================================*/
+extern int         Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, int fVerbose );
+/*=== retFlow.c ========================================================*/
+extern void        Abc_NtkMaxFlowTest( Abc_Ntk_t * pNtk );
+extern Vec_Ptr_t * Abc_NtkMaxFlow( Abc_Ntk_t * pNtk, int fForward, int fVerbose );
+/*=== retFwd.c ========================================================*/
+extern int         Abc_NtkRetimeForward( Abc_Ntk_t * pNtk, int fVerbose );
+/*=== retInit.c ========================================================*/
+extern void        Abc_NtkRetimeInitialValues( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkMiter, int fVerbose );
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/ret/ret_.c b/src/opt/ret/ret_.c
new file mode 100644
index 00000000..89625e17
--- /dev/null
+++ b/src/opt/ret/ret_.c
@@ -0,0 +1,48 @@
+/**CFile****************************************************************
+
+  FileName    [ret_.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Retiming package.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Oct 31, 2006.]
+
+  Revision    [$Id: ret_.c,v 1.00 2006/10/31 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "retInt.h"
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/opt/rwr/rwr.h b/src/opt/rwr/rwr.h
index f8c40a7c..eda2b85f 100644
--- a/src/opt/rwr/rwr.h
+++ b/src/opt/rwr/rwr.h
@@ -106,10 +106,10 @@ struct Rwr_Node_t_ // 24 bytes
 };
 
 // manipulation of complemented attributes
-static inline bool         Rwr_IsComplement( Rwr_Node_t * p )    { return (bool)(((unsigned)p) & 01);           }
-static inline Rwr_Node_t * Rwr_Regular( Rwr_Node_t * p )         { return (Rwr_Node_t *)((unsigned)(p) & ~01);  }
-static inline Rwr_Node_t * Rwr_Not( Rwr_Node_t * p )             { return (Rwr_Node_t *)((unsigned)(p) ^  01);  }
-static inline Rwr_Node_t * Rwr_NotCond( Rwr_Node_t * p, int c )  { return (Rwr_Node_t *)((unsigned)(p) ^ (c));  }
+static inline bool         Rwr_IsComplement( Rwr_Node_t * p )    { return (bool)(((unsigned long)p) & 01);           }
+static inline Rwr_Node_t * Rwr_Regular( Rwr_Node_t * p )         { return (Rwr_Node_t *)((unsigned long)(p) & ~01);  }
+static inline Rwr_Node_t * Rwr_Not( Rwr_Node_t * p )             { return (Rwr_Node_t *)((unsigned long)(p) ^  01);  }
+static inline Rwr_Node_t * Rwr_NotCond( Rwr_Node_t * p, int c )  { return (Rwr_Node_t *)((unsigned long)(p) ^ (c));  }
 
 ////////////////////////////////////////////////////////////////////////
 ///                      MACRO DEFINITIONS                           ///
author	Alan Mishchenko <alanmi@berkeley.edu>	2006-11-02 08:01:00 -0800
committer	Alan Mishchenko <alanmi@berkeley.edu>	2006-11-02 08:01:00 -0800
commit	faf1265bb82f934cc14b6106ccce89e37203efbd (patch)
tree	f6d69ce4adca5d7e1fdccd3e9848220d6744405d /src/opt
parent	73bb7932f7edad95086d67a795444537c438309e (diff)
download	abc-faf1265bb82f934cc14b6106ccce89e37203efbd.tar.gz abc-faf1265bb82f934cc14b6106ccce89e37203efbd.tar.bz2 abc-faf1265bb82f934cc14b6106ccce89e37203efbd.zip