Version abc80123

7 files changed, 296 insertions, 63 deletions

diff --git a/src/map/if/if.h b/src/map/if/if.h
index 07816790..b3d2d745 100644
--- a/src/map/if/if.h
+++ b/src/map/if/if.h
@@ -36,6 +36,7 @@ extern "C" {
 #include <time.h>
 #include "vec.h"
 #include "mem.h"
+#include "tim.h"
 
 ////////////////////////////////////////////////////////////////////////
 ///                         PARAMETERS                               ///
@@ -127,7 +128,8 @@ struct If_Man_t_
     Vec_Ptr_t *        vCis;          // the primary inputs
     Vec_Ptr_t *        vCos;          // the primary outputs
     Vec_Ptr_t *        vObjs;         // all objects
-    Vec_Ptr_t *        vMapped;       // objects used in the mapping
+    Vec_Ptr_t *        vObjsRev;      // reverse topological order of objects
+//    Vec_Ptr_t *        vMapped;       // objects used in the mapping
     Vec_Ptr_t *        vTemp;         // temporary array
     int                nObjs[IF_VOID];// the number of objects by type
     // various data
@@ -161,6 +163,8 @@ struct If_Man_t_
     If_Set_t *         pMemAnd;       // memory for AND cutsets
     If_Set_t *         pFreeList;     // the list of free cutsets
     int                nSmallSupp;    // the small support
+    // timing manager
+    Tim_Man_t *        pManTim;
 };
 
 // priority cut
@@ -202,6 +206,7 @@ struct If_Obj_t_
     unsigned           fVisit  :  1;  // multipurpose mark
     unsigned           Level   : 22;  // logic level of the node
     int                Id;            // integer ID
+    int                IdPio;         // integer ID of PIs/POs
     int                nRefs;         // the number of references
     int                nVisits;       // the number of visits to this node
     int                nVisitsCopy;   // the number of visits to this node
@@ -236,7 +241,7 @@ static inline If_Obj_t * If_ManObj( If_Man_t * p, int i )                    { r
 static inline int        If_ObjIsConst1( If_Obj_t * pObj )                   { return pObj->Type == IF_CONST1;       }
 static inline int        If_ObjIsCi( If_Obj_t * pObj )                       { return pObj->Type == IF_CI;           }
 static inline int        If_ObjIsCo( If_Obj_t * pObj )                       { return pObj->Type == IF_CO;           }
-static inline int        If_ObjIsPi( If_Obj_t * pObj )                       { return If_ObjIsCi(pObj) && pObj->pFanin0 == NULL; }
+//static inline int        If_ObjIsPi( If_Obj_t * pObj )                       { return If_ObjIsCi(pObj) && pObj->pFanin0 == NULL; }
 static inline int        If_ObjIsLatch( If_Obj_t * pObj )                    { return If_ObjIsCi(pObj) && pObj->pFanin0 != NULL; }
 static inline int        If_ObjIsAnd( If_Obj_t * pObj )                      { return pObj->Type == IF_AND;          }
 
@@ -298,9 +303,12 @@ static inline float      If_CutLutArea( If_Man_t * p, If_Cut_t * pCut )      { r
     Vec_PtrForEachEntryStart( p->vCos, pObj, i, If_ManCoNum(p) - p->pPars->nLatches )
 #define If_ManForEachLatchOutput( p, pObj, i )                                 \
     Vec_PtrForEachEntryStart( p->vCis, pObj, i, If_ManCiNum(p) - p->pPars->nLatches )
-// iterator over all objects, including those currently not used
+// iterator over all objects in topological order
 #define If_ManForEachObj( p, pObj, i )                                         \
     Vec_PtrForEachEntry( p->vObjs, pObj, i )
+// iterator over all objects in reverse topological order
+#define If_ManForEachObjReverse( p, pObj, i )                                  \
+    Vec_PtrForEachEntry( p->vObjsRev, pObj, i )
 // iterator over logic nodes 
 #define If_ManForEachNode( p, pObj, i )                                        \
     If_ManForEachObj( p, pObj, i ) if ( pObj->Type != IF_AND ) {} else
@@ -385,6 +393,11 @@ extern float           If_ManScanMappingSeq( If_Man_t * p );
 extern void            If_ManResetOriginalRefs( If_Man_t * p );
 extern int             If_ManCrossCut( If_Man_t * p );
 
+extern Vec_Ptr_t *     If_ManReverseOrder( If_Man_t * p );
+extern void            If_ManMarkMapping( If_Man_t * p );
+extern Vec_Ptr_t *     If_ManCollectMappingDirect( If_Man_t * p );
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/map/if/ifCore.c b/src/map/if/ifCore.c
index 59ad5a1c..f7124703 100644
--- a/src/map/if/ifCore.c
+++ b/src/map/if/ifCore.c
@@ -49,13 +49,15 @@ int If_ManPerformMapping( If_Man_t * p )
     If_ManSetupCiCutSets( p );
     // allocate memory for other cutsets
     If_ManSetupSetAll( p, If_ManCrossCut(p) );
+    // derive reverse top order
+    p->vObjsRev = If_ManReverseOrder( p );
 
     // try sequential mapping
     if ( p->pPars->fSeqMap )
     {
-        int RetValue;
-//        printf( "Currently sequential mapping is not performed.\n" );
-        RetValue = If_ManPerformMappingSeq( p );
+        int RetValue = 1;
+        printf( "Currently sequential mapping is not performed.\n" );
+//        RetValue = If_ManPerformMappingSeq( p );
         return RetValue;
 //        return 1;
     }
diff --git a/src/map/if/ifMan.c b/src/map/if/ifMan.c
index 977d69c9..6b21919b 100644
--- a/src/map/if/ifMan.c
+++ b/src/map/if/ifMan.c
@@ -56,7 +56,7 @@ If_Man_t * If_ManStart( If_Par_t * pPars )
     p->vCis    = Vec_PtrAlloc( 100 );
     p->vCos    = Vec_PtrAlloc( 100 );
     p->vObjs   = Vec_PtrAlloc( 100 );
-    p->vMapped = Vec_PtrAlloc( 100 );
+//    p->vMapped = Vec_PtrAlloc( 100 );
     p->vTemp   = Vec_PtrAlloc( 100 );
     // prepare the memory manager
     p->nTruthWords = p->pPars->fTruth? If_CutTruthWords( p->pPars->nLutSize ) : 0;
@@ -100,7 +100,7 @@ void If_ManRestart( If_Man_t * p )
     Vec_PtrClear( p->vCis );
     Vec_PtrClear( p->vCos );
     Vec_PtrClear( p->vObjs );
-    Vec_PtrClear( p->vMapped );
+//    Vec_PtrClear( p->vMapped );
     Vec_PtrClear( p->vTemp );
     Mem_FixedRestart( p->pMemObj );
     // create the constant node
@@ -128,10 +128,11 @@ void If_ManStop( If_Man_t * p )
     Vec_PtrFree( p->vCis );
     Vec_PtrFree( p->vCos );
     Vec_PtrFree( p->vObjs );
-    Vec_PtrFree( p->vMapped );
+//    Vec_PtrFree( p->vMapped );
     Vec_PtrFree( p->vTemp );
+    if ( p->vObjsRev )    Vec_PtrFree( p->vObjsRev );
     if ( p->vLatchOrder ) Vec_PtrFree( p->vLatchOrder );
-    if ( p->vLags ) Vec_IntFree( p->vLags );
+    if ( p->vLags )       Vec_IntFree( p->vLags );
     Mem_FixedStop( p->pMemObj, 0 );
     FREE( p->pMemCi );
     FREE( p->pMemAnd );
@@ -141,6 +142,8 @@ void If_ManStop( If_Man_t * p )
         FREE( p->pPars->pTimesArr );
     if ( p->pPars->pTimesReq )
         FREE( p->pPars->pTimesReq );
+    if ( p->pManTim )
+        Tim_ManStop( p->pManTim );
     free( p );
 }
 
@@ -160,6 +163,7 @@ If_Obj_t * If_ManCreateCi( If_Man_t * p )
     If_Obj_t * pObj;
     pObj = If_ManSetupObj( p );
     pObj->Type = IF_CI;
+    pObj->IdPio = Vec_PtrSize( p->vCis );
     Vec_PtrPush( p->vCis, pObj );
     p->nObjs[IF_CI]++;
     return pObj;
@@ -180,10 +184,12 @@ If_Obj_t * If_ManCreateCo( If_Man_t * p, If_Obj_t * pDriver )
 {
     If_Obj_t * pObj;
     pObj = If_ManSetupObj( p );
+    pObj->IdPio = Vec_PtrSize( p->vCos );
     Vec_PtrPush( p->vCos, pObj );
     pObj->Type = IF_CO;
     pObj->fCompl0 = If_IsComplement(pDriver); pDriver = If_Regular(pDriver);
     pObj->pFanin0 = pDriver; pDriver->nRefs++; 
+    pObj->Level   = pDriver->Level;
     p->nObjs[IF_CO]++;
     return pObj;
 }
diff --git a/src/map/if/ifMap.c b/src/map/if/ifMap.c
index 7228480a..1ac5ef21 100644
--- a/src/map/if/ifMap.c
+++ b/src/map/if/ifMap.c
@@ -260,6 +260,7 @@ int If_ManPerformMappingRound( If_Man_t * p, int nCutsUsed, int Mode, int fPrepr
 //    ProgressBar * pProgress;
     If_Obj_t * pObj;
     int i, clk = clock();
+    float arrTime;
     assert( Mode >= 0 && Mode <= 2 );
     // set the sorting function
     if ( Mode || p->pPars->fArea ) // area
@@ -271,14 +272,56 @@ int If_ManPerformMappingRound( If_Man_t * p, int nCutsUsed, int Mode, int fPrepr
     // set the cut number
     p->nCutsUsed   = nCutsUsed;
     p->nCutsMerged = 0;
-    // map the internal nodes
-//    pProgress = Extra_ProgressBarStart( stdout, If_ManObjNum(p) );
+    // make sure the visit counters are all zero
     If_ManForEachNode( p, pObj, i )
+        assert( pObj->nVisits == pObj->nVisitsCopy );
+    // map the internal nodes
+    if ( p->pManTim != NULL )
+    {
+        Tim_ManIncrementTravId( p->pManTim );
+        If_ManForEachObj( p, pObj, i )
+        {
+            if ( If_ObjIsAnd(pObj) )
+            {
+                If_ObjPerformMappingAnd( p, pObj, Mode, fPreprocess );
+                if ( pObj->fRepr )
+                    If_ObjPerformMappingChoice( p, pObj, Mode, fPreprocess );
+            }
+            else if ( If_ObjIsCi(pObj) )
+            {
+                arrTime = Tim_ManGetPiArrival( p->pManTim, pObj->IdPio );
+                If_ObjSetArrTime( pObj, arrTime );
+/*
+    if ( pObj->IdPio >= 2000 )
+    {
+        int x = 0;
+        printf( "+%d %6.3f  ", pObj->IdPio, arrTime );
+    }
+*/
+            }
+            else if ( If_ObjIsCo(pObj) )
+            {
+                arrTime = If_ObjArrTime( If_ObjFanin0(pObj) );
+                Tim_ManSetPoArrival( p->pManTim, pObj->IdPio, arrTime );
+            }
+            else if ( If_ObjIsConst1(pObj) )
+            {
+            }
+            else
+                assert( 0 );
+        }
+//        Tim_ManPrint( p->pManTim );
+    }
+    else
     {
-//        Extra_ProgressBarUpdate( pProgress, i, pLabel );
-        If_ObjPerformMappingAnd( p, pObj, Mode, fPreprocess );
-        if ( pObj->fRepr )
-            If_ObjPerformMappingChoice( p, pObj, Mode, fPreprocess );
+    //    pProgress = Extra_ProgressBarStart( stdout, If_ManObjNum(p) );
+        If_ManForEachNode( p, pObj, i )
+        {
+    //        Extra_ProgressBarUpdate( pProgress, i, pLabel );
+            If_ObjPerformMappingAnd( p, pObj, Mode, fPreprocess );
+            if ( pObj->fRepr )
+                If_ObjPerformMappingChoice( p, pObj, Mode, fPreprocess );
+        }
     }
 //    Extra_ProgressBarStop( pProgress );
     // make sure the visit counters are all zero
@@ -286,6 +329,7 @@ int If_ManPerformMappingRound( If_Man_t * p, int nCutsUsed, int Mode, int fPrepr
         assert( pObj->nVisits == 0 );
     // compute required times and stats
     If_ManComputeRequired( p );
+//    Tim_ManPrint( p->pManTim );
     if ( p->pPars->fVerbose )
     {
         char Symb = fPreprocess? 'P' : ((Mode == 0)? 'D' : ((Mode == 1)? 'F' : 'A'));
diff --git a/src/map/if/ifTime.c b/src/map/if/ifTime.c
index 60417c67..3d1dab1b 100644
--- a/src/map/if/ifTime.c
+++ b/src/map/if/ifTime.c
@@ -99,6 +99,13 @@ float If_CutDelay( If_Man_t * p, If_Cut_t * pCut )
             {
                 If_CutForEachLeaf( p, pCut, pLeaf, i )
                 {
+/*
+                    if ( pLeaf->IdPio > 2000 )
+                    {
+                        int x = 0;
+                        printf( "-%d %6.3f  ", pLeaf->IdPio, If_ObjCutBest(pLeaf)->Delay );
+                    }
+*/
                     DelayCur = If_ObjCutBest(pLeaf)->Delay;
                     Delay = IF_MAX( Delay, DelayCur );
                 }
diff --git a/src/map/if/ifUtil.c b/src/map/if/ifUtil.c
index 3bb39e2f..2624efd0 100644
--- a/src/map/if/ifUtil.c
+++ b/src/map/if/ifUtil.c
@@ -144,75 +144,136 @@ void If_ManComputeRequired( If_Man_t * p )
 {
     If_Obj_t * pObj;
     int i, Counter;
+    float reqTime;
 
     // compute area, clean required times, collect nodes used in the mapping
-    p->nNets = 0;
-    p->AreaGlo = If_ManScanMapping( p );
+//    p->AreaGlo = If_ManScanMapping( p );
+    If_ManMarkMapping( p );
 
-    // consider the case when the required times are given
-    if ( p->pPars->pTimesReq )
+    if ( p->pManTim == NULL )
     {
-        assert( !p->pPars->fAreaOnly );
-        // make sure that the required time hold
-        Counter = 0;
-        If_ManForEachCo( p, pObj, i )
+        // consider the case when the required times are given
+        if ( p->pPars->pTimesReq )
         {
-            if ( If_ObjArrTime(If_ObjFanin0(pObj)) > p->pPars->pTimesReq[i] + p->fEpsilon )
+            assert( !p->pPars->fAreaOnly );
+            // make sure that the required time hold
+            Counter = 0;
+            If_ManForEachCo( p, pObj, i )
             {
-                Counter++;
-//                printf( "Required times are violated for output %d (arr = %d; req = %d).\n", 
-//                    i, (int)If_ObjArrTime(If_ObjFanin0(pObj)), (int)p->pPars->pTimesReq[i] );
+                if ( If_ObjArrTime(If_ObjFanin0(pObj)) > p->pPars->pTimesReq[i] + p->fEpsilon )
+                {
+                    Counter++;
+    //                printf( "Required times are violated for output %d (arr = %d; req = %d).\n", 
+    //                    i, (int)If_ObjArrTime(If_ObjFanin0(pObj)), (int)p->pPars->pTimesReq[i] );
+                }
+                If_ObjFanin0(pObj)->Required = p->pPars->pTimesReq[i];
             }
-            If_ObjFanin0(pObj)->Required = p->pPars->pTimesReq[i];
+            if ( Counter )
+                printf( "Required times are violated for %d outputs.\n", Counter );
         }
-        if ( Counter )
-            printf( "Required times are violated for %d outputs.\n", Counter );
-    }
-    else
-    {
-        // get the global required times
-        p->RequiredGlo = If_ManDelayMax( p, 0 );
-        // update the required times according to the target
-        if ( p->pPars->DelayTarget != -1 )
+        else
         {
-            if ( p->RequiredGlo > p->pPars->DelayTarget + p->fEpsilon )
+            // get the global required times
+            p->RequiredGlo = If_ManDelayMax( p, 0 );
+            // update the required times according to the target
+            if ( p->pPars->DelayTarget != -1 )
             {
-                if ( p->fNextRound == 0 )
+                if ( p->RequiredGlo > p->pPars->DelayTarget + p->fEpsilon )
                 {
-                    p->fNextRound = 1;
-                    printf( "Cannot meet the target required times (%4.2f). Mapping continues anyway.\n", p->pPars->DelayTarget );
+                    if ( p->fNextRound == 0 )
+                    {
+                        p->fNextRound = 1;
+                        printf( "Cannot meet the target required times (%4.2f). Mapping continues anyway.\n", p->pPars->DelayTarget );
+                    }
                 }
-            }
-            else if ( p->RequiredGlo < p->pPars->DelayTarget - p->fEpsilon )
-            {
-                if ( p->fNextRound == 0 )
+                else if ( p->RequiredGlo < p->pPars->DelayTarget - p->fEpsilon )
                 {
-                    p->fNextRound = 1;
-                    printf( "Relaxing the required times from (%4.2f) to the target (%4.2f).\n", p->RequiredGlo, p->pPars->DelayTarget );
+                    if ( p->fNextRound == 0 )
+                    {
+                        p->fNextRound = 1;
+                        printf( "Relaxing the required times from (%4.2f) to the target (%4.2f).\n", p->RequiredGlo, p->pPars->DelayTarget );
+                    }
+                    p->RequiredGlo = p->pPars->DelayTarget;
                 }
-                p->RequiredGlo = p->pPars->DelayTarget;
             }
+            // do not propagate required times if area minimization is requested
+            if ( p->pPars->fAreaOnly ) 
+                return;
+            // set the required times for the POs
+            if ( p->pPars->fLatchPaths )
+            {
+                If_ManForEachLatchInput( p, pObj, i )
+                    If_ObjFanin0(pObj)->Required = p->RequiredGlo;
+            }
+            else 
+            {
+                If_ManForEachCo( p, pObj, i )
+                    If_ObjFanin0(pObj)->Required = p->RequiredGlo;
+            }
+        }
+        // go through the nodes in the reverse topological order
+    //    Vec_PtrForEachEntry( p->vMapped, pObj, i )
+    //        If_CutPropagateRequired( p, If_ObjCutBest(pObj), pObj->Required );
+        If_ManForEachObjReverse( p, pObj, i )
+        {
+            if ( pObj->nRefs == 0 )
+                continue;
+            If_CutPropagateRequired( p, If_ObjCutBest(pObj), pObj->Required );
         }
+    }
+    else
+    {
+        // get the global required times
+        p->RequiredGlo = If_ManDelayMax( p, 0 );
         // do not propagate required times if area minimization is requested
         if ( p->pPars->fAreaOnly ) 
             return;
         // set the required times for the POs
+        Tim_ManIncrementTravId( p->pManTim );
         if ( p->pPars->fLatchPaths )
         {
+            assert( 0 );
+            If_ManForEachPo( p, pObj, i )
+                Tim_ManSetPoRequired( p->pManTim, pObj->IdPio, IF_FLOAT_LARGE );
             If_ManForEachLatchInput( p, pObj, i )
-                If_ObjFanin0(pObj)->Required = p->RequiredGlo;
+                Tim_ManSetPoRequired( p->pManTim, pObj->IdPio, p->RequiredGlo );
         }
-        else 
+        else  
         {
-            If_ManForEachCo( p, pObj, i )
-                If_ObjFanin0(pObj)->Required = p->RequiredGlo;
+            Tim_ManSetPoRequiredAll( p->pManTim, p->RequiredGlo );
+//            If_ManForEachCo( p, pObj, i )
+//                Tim_ManSetPoRequired( p->pManTim, pObj->IdPio, p->RequiredGlo );
+        }
+        // go through the nodes in the reverse topological order
+        If_ManForEachObjReverse( p, pObj, i )
+        {
+            if ( If_ObjIsAnd(pObj) )
+            {
+                if ( pObj->nRefs == 0 )
+                    continue;
+                If_CutPropagateRequired( p, If_ObjCutBest(pObj), pObj->Required );
+            }
+            else if ( If_ObjIsCi(pObj) )
+            {
+                reqTime = pObj->Required;
+                Tim_ManSetPiRequired( p->pManTim, pObj->IdPio, reqTime );
+            }
+            else if ( If_ObjIsCo(pObj) )
+            {
+                reqTime = Tim_ManGetPoRequired( p->pManTim, pObj->IdPio );
+                If_ObjFanin0(pObj)->Required = IF_MIN( reqTime, If_ObjFanin0(pObj)->Required );
+            }
+            else if ( If_ObjIsConst1(pObj) )
+            {
+            }
+            else // add the node to the mapper
+                assert( 0 );
         }
     }
-    // go through the nodes in the reverse topological order
-    Vec_PtrForEachEntry( p->vMapped, pObj, i )
-        If_CutPropagateRequired( p, If_ObjCutBest(pObj), pObj->Required );
 }
  
+#if 0
+
 /**Function*************************************************************
 
   Synopsis    [Computes area, references, and nodes used in the mapping.]
@@ -264,6 +325,7 @@ float If_ManScanMapping( If_Man_t * p )
     int i;
     assert( !p->pPars->fLiftLeaves );
     // clean all references
+    p->nNets = 0;
     If_ManForEachObj( p, pObj, i )
     {
         pObj->Required = IF_FLOAT_LARGE;
@@ -392,6 +454,8 @@ float If_ManScanMappingSeq( If_Man_t * p )
     return aArea;
 }
 
+#endif
+
 /**Function*************************************************************
 
   Synopsis    [Computes area, references, and nodes used in the mapping.]
@@ -471,7 +535,74 @@ int If_ManCrossCut( If_Man_t * p )
 
 /**Function*************************************************************
 
-  Synopsis    [Computes cross-cut of the circuit.]
+  Synopsis    [Computes the reverse topological order of nodes.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * If_ManReverseOrder( If_Man_t * p )
+{
+    Vec_Ptr_t * vOrder;
+    If_Obj_t * pObj, ** ppStore;
+    int i;
+    // allocate place to store the nodes
+    ppStore = ALLOC( If_Obj_t *, p->nLevelMax + 1 );
+    memset( ppStore, 0, sizeof(If_Obj_t *) * (p->nLevelMax + 1) );
+    // add the nodes
+    If_ManForEachObj( p, pObj, i )
+    {
+        assert( pObj->Level >= 0 && pObj->Level <= (unsigned)p->nLevelMax );
+        pObj->pCopy = (char *)ppStore[pObj->Level]; 
+        ppStore[pObj->Level] = pObj;
+    }
+    vOrder = Vec_PtrAlloc( If_ManObjNum(p) );
+    for ( i = p->nLevelMax; i >= 0; i-- )
+        for ( pObj = ppStore[i]; pObj; pObj = pObj->pCopy )
+            Vec_PtrPush( vOrder, pObj );
+    free( ppStore );
+    // print the order
+//    Vec_PtrForEachEntry( vOrder, pObj, i )
+//        printf( "Obj %2d   Type %d  Level = %d\n", pObj->Id, pObj->Type, pObj->Level );
+    return vOrder;
+}
+ 
+/**Function*************************************************************
+
+  Synopsis    [Computes area, references, and nodes used in the mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+float If_ManMarkMapping_rec( If_Man_t * p, If_Obj_t * pObj )
+{
+    If_Obj_t * pLeaf;
+    If_Cut_t * pCutBest;
+    float aArea;
+    int i;
+    if ( pObj->nRefs++ || If_ObjIsCi(pObj) || If_ObjIsConst1(pObj) )
+        return 0.0;
+    // store the node in the structure by level
+    assert( If_ObjIsAnd(pObj) );
+    // visit the transitive fanin of the selected cut
+    pCutBest = If_ObjCutBest(pObj);
+    p->nNets += pCutBest->nLeaves;
+    aArea = If_CutLutArea( p, pCutBest );
+    If_CutForEachLeaf( p, pCutBest, pLeaf, i )
+        aArea += If_ManMarkMapping_rec( p, pLeaf );
+    return aArea;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes area, references, and nodes used in the mapping.]
 
   Description []
                
@@ -480,13 +611,44 @@ int If_ManCrossCut( If_Man_t * p )
   SeeAlso     []
 
 ***********************************************************************/
-int If_ManCountTrueArea( If_Man_t * p )
+void If_ManMarkMapping( If_Man_t * p )
 {
     If_Obj_t * pObj;
-    int i, Area = 0;
-    Vec_PtrForEachEntry( p->vMapped, pObj, i )
-        Area += 1 + (If_ObjCutBest(pObj)->nLeaves > (unsigned)p->pPars->nLutSize / 2);
-    return Area;
+    int i;
+    If_ManForEachObj( p, pObj, i )
+    {
+        pObj->Required = IF_FLOAT_LARGE;
+        pObj->nVisits = pObj->nVisitsCopy;
+        pObj->nRefs = 0;
+    }
+    p->nNets = 0;
+    p->AreaGlo = 0.0;
+    If_ManForEachCo( p, pObj, i )
+        p->AreaGlo += If_ManMarkMapping_rec( p, If_ObjFanin0(pObj) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects nodes used in the mapping in the topological order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * If_ManCollectMappingDirect( If_Man_t * p )
+{
+    Vec_Ptr_t * vOrder;
+    If_Obj_t * pObj;
+    int i;
+    If_ManMarkMapping( p );
+    vOrder = Vec_PtrAlloc( If_ManObjNum(p) );
+    If_ManForEachObj( p, pObj, i )
+        if ( If_ObjIsAnd(pObj) && pObj->nRefs )
+            Vec_PtrPush( vOrder, pObj );
+    return vOrder;
 }
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/map/if/module.make b/src/map/if/module.make
index f3d189be..c14428da 100644
--- a/src/map/if/module.make
+++ b/src/map/if/module.make
@@ -3,7 +3,6 @@ SRC +=  src/map/if/ifCore.c \
     src/map/if/ifMan.c \
     src/map/if/ifMap.c \
     src/map/if/ifReduce.c \
-    src/map/if/ifSeq.c \
     src/map/if/ifTime.c \
     src/map/if/ifTruth.c \
     src/map/if/ifUtil.c