Improvements to gate sizing.

1 files changed, 240 insertions, 89 deletions

diff --git a/src/map/scl/sclUpsize.c b/src/map/scl/sclUpsize.c
index 8f4d2ca0..b648f720 100644
--- a/src/map/scl/sclUpsize.c
+++ b/src/map/scl/sclUpsize.c
@@ -45,35 +45,45 @@ extern Vec_Int_t * Abc_SclFindCriticalCoWindow( SC_Man * p, int Window );
   SeeAlso     []
 
 ***********************************************************************/
-void Abc_SclFindTFO_rec( Abc_Obj_t * pObj, Vec_Int_t * vVisited )
+void Abc_SclFindTFO_rec( Abc_Obj_t * pObj, Vec_Int_t * vNodes, Vec_Int_t * vCos )
 {
     Abc_Obj_t * pNext;
     int i;
-//    if ( Abc_ObjIsCo(pObj) )
-//        return;
     if ( Abc_NodeIsTravIdCurrent( pObj ) )
         return;
     Abc_NodeSetTravIdCurrent( pObj );
+    if ( Abc_ObjIsCo(pObj) )
+    {
+        Vec_IntPush( vCos, Abc_ObjId(pObj) );
+        return;
+    }
+    assert( Abc_ObjIsNode(pObj) );
     Abc_ObjForEachFanout( pObj, pNext, i )
-        Abc_SclFindTFO_rec( pNext, vVisited );
-    Vec_IntPush( vVisited, Abc_ObjId(pObj) );
+        Abc_SclFindTFO_rec( pNext, vNodes, vCos );
+    Vec_IntPush( vNodes, Abc_ObjId(pObj) );
 }
 Vec_Int_t * Abc_SclFindTFO( Abc_Ntk_t * p, Vec_Int_t * vPath )
 {
-    Vec_Int_t * vVisited;
+    Vec_Int_t * vNodes, * vCos;
     Abc_Obj_t * pObj, * pFanin;
     int i, k;
     assert( Vec_IntSize(vPath) > 0 );
-    vVisited = Vec_IntAlloc( 100 );
+    vCos = Vec_IntAlloc( 100 );
+    vNodes = Vec_IntAlloc( 100 );
     // collect nodes in the TFO
     Abc_NtkIncrementTravId( p ); 
     Abc_NtkForEachObjVec( vPath, p, pObj, i )
         Abc_ObjForEachFanin( pObj, pFanin, k )
             if ( Abc_ObjIsNode(pFanin) )
-                Abc_SclFindTFO_rec( pFanin, vVisited );
+                Abc_SclFindTFO_rec( pFanin, vNodes, vCos );
     // reverse order
-    Vec_IntReverseOrder( vVisited );
-    return vVisited;
+    Vec_IntReverseOrder( vNodes );
+//    Vec_IntSort( vNodes, 0 );
+//Vec_IntPrint( vNodes );
+//Vec_IntPrint( vCos );
+    Vec_IntAppend( vNodes, vCos );
+    Vec_IntFree( vCos );
+    return vNodes;
 }
 
 /**Function*************************************************************
@@ -143,7 +153,11 @@ Vec_Int_t * Abc_SclFindCriticalNodeWindow( SC_Man * p, Vec_Int_t * vPathCos, int
     int i;
     Abc_NtkIncrementTravId( p->pNtk ); 
     Abc_NtkForEachObjVec( vPathCos, p->pNtk, pObj, i )
-        Abc_SclFindCriticalNodeWindow_rec( p, Abc_ObjFanin0(pObj), vPath, fSlack - (fMaxArr - Abc_SclObjTimeMax(p, pObj)) );
+    {
+        float fSlackThis = fSlack - (fMaxArr - Abc_SclObjTimeMax(p, pObj));
+        assert( fSlackThis >= 0 );
+        Abc_SclFindCriticalNodeWindow_rec( p, Abc_ObjFanin0(pObj), vPath, fSlackThis );
+    }
     // label critical nodes
     Abc_NtkForEachObjVec( vPathCos, p->pNtk, pObj, i )
         pObj->fMarkA = 1;
@@ -199,12 +213,13 @@ Vec_Int_t * Abc_SclFindNodesToUpdate( Abc_Obj_t * pPivot, Vec_Int_t ** pvEvals )
         assert( pObj->fMarkB == 0 );
         pObj->fMarkB = 1;
     }
-    // collect nodes pointed to by non-labeled nodes
+    // collect nodes visible from the critical paths
     *pvEvals = Vec_IntAlloc( 10 );
     Abc_NtkForEachObjVec( vNodes, p, pObj, i )
         Abc_ObjForEachFanout( pObj, pNext, k )
             if ( pNext->fMarkA && !pNext->fMarkB )
             {
+                assert( pObj->fMarkB );
                 Vec_IntPush( *pvEvals, Abc_ObjId(pObj) );
                 break;
             }
@@ -218,32 +233,7 @@ Vec_Int_t * Abc_SclFindNodesToUpdate( Abc_Obj_t * pPivot, Vec_Int_t ** pvEvals )
 
 /**Function*************************************************************
 
-  Synopsis    [Compute gain in changing the gate size.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-float Abc_SclFindGain( SC_Man * p, Vec_Int_t * vCone, Vec_Int_t * vEvals )
-{
-    double dGain = 0;
-    Abc_Obj_t * pObj;
-    int i;
-    Abc_SclConeStore( p, vCone );
-    Abc_SclTimeCone( p, vCone );
-    Abc_NtkForEachObjVec( vEvals, p->pNtk, pObj, i )
-        dGain += Abc_SclObjGain( p, pObj );
-    Abc_SclConeRestore( p, vCone );
-    dGain /= Vec_IntSize(vEvals);
-    return (float)dGain;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Begin by upsizing gates will many fanouts.]
+  Synopsis    [Computes the set of gates to upsize.]
 
   Description []
                
@@ -252,51 +242,75 @@ float Abc_SclFindGain( SC_Man * p, Vec_Int_t * vCone, Vec_Int_t * vEvals )
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_SclFindUpsizes( SC_Man * p, Vec_Int_t * vPathNodes, int Ratio )
+int Abc_SclFindUpsizes( SC_Man * p, Vec_Int_t * vPathNodes, int Ratio, int Notches )
 {
     SC_Cell * pCellOld, * pCellNew;
+    Vec_Int_t * vChamps;  // best gate for each node
     Vec_Flt_t * vSavings; // best gain for each node
-    Vec_Int_t * vBests;   // best gate for each node
-    Vec_Int_t * vCone, * vEvals, * vUpdates;
-    Abc_Obj_t * pObj;
-    float dGain, dGainBest = 0;
-    int i, k, Entry, gateBest = -1;
+    Vec_Int_t * vRecalcs, * vEvals, * vUpdate;
+    Abc_Obj_t * pObj, * pTemp;
+    float dGain, dGainBest;
+    int i, k, n, Entry, gateBest;
     int nUpsizes = 0;
-
 //    return nUpsizes;
 
+    // compute savings due to upsizing each node
+    vChamps = Vec_IntAlloc( Vec_IntSize(vPathNodes) );
     vSavings = Vec_FltAlloc( Vec_IntSize(vPathNodes) );
-    vBests = Vec_IntAlloc( Vec_IntSize(vPathNodes) );
     Abc_NtkForEachObjVec( vPathNodes, p->pNtk, pObj, i )
     {
-        dGainBest = 0;
-        pCellOld  = Abc_SclObjCell( p, pObj );
+        // compute nodes to recalculate timing and nodes to evaluate afterwards
+        vRecalcs = Abc_SclFindNodesToUpdate( pObj, &vEvals );
+        // save old gate, timing, fanin load
+        pCellOld = Abc_SclObjCell( p, pObj );
+        Abc_SclConeStore( p, vRecalcs );
+        Abc_SclLoadStore( p, pObj );
         // try different gate sizes for this node
-        vCone = Abc_SclFindNodesToUpdate( pObj, &vEvals );
+        dGainBest = 0.0;
+        gateBest = -1;
         SC_RingForEachCell( pCellOld, pCellNew, k )
         {
             if ( pCellNew == pCellOld )
                 continue;
+            if ( k > Notches )
+                break;
+//printf( "Tring %s\n", pCellNew->pName );
+            // set new cell
             Abc_SclObjSetCell( p, pObj, pCellNew );
-    //printf( "changing %s for %s at node %d   ", pCellOld->pName, pCellNew->pName, Abc_ObjId(pObj) );
             Abc_SclUpdateLoad( p, pObj, pCellOld, pCellNew );
-            dGain = Abc_SclFindGain( p, vCone, vEvals );
-            Abc_SclUpdateLoad( p, pObj, pCellNew, pCellOld );
-    //printf( "gain is %f\n", dGain );
+            // recompute timing
+            Abc_SclTimeCone( p, vRecalcs );
+            // set old cell
+            Abc_SclObjSetCell( p, pObj, pCellOld );
+            Abc_SclLoadRestore( p, pObj );
+            // evaluate gain
+            dGain = 0.0;
+            Abc_NtkForEachObjVec( vEvals, p->pNtk, pTemp, n )
+                dGain += Abc_SclObjGain( p, pTemp );
+            dGain /= Vec_IntSize(vEvals);
+            if ( dGain <= 0.0 )
+                continue;
+            // put back timing and load
+//printf( "gain is %f\n", dGain );
             if ( dGainBest < dGain )
             {
                 dGainBest = dGain;
                 gateBest = pCellNew->Id;
             }
         }
+//printf( "gain is %f\n", dGainBest );
+        // remember savings
         assert( dGainBest >= 0.0 );
-        Vec_IntFree( vCone );
-        Vec_IntFree( vEvals );
-        Abc_SclObjSetCell( p, pObj, pCellOld );
+        Vec_IntPush( vChamps, gateBest );
         Vec_FltPush( vSavings, dGainBest );
-        Vec_IntPush( vBests, gateBest );
+        // put back old cell and timing
+        Abc_SclObjSetCell( p, pObj, pCellOld );
+        Abc_SclConeRestore( p, vRecalcs );
+        // cleanup
+        Vec_IntFree( vRecalcs );
+        Vec_IntFree( vEvals );
     }
-    assert( Vec_IntSize(vBests) == Vec_IntSize(vPathNodes) );
+    assert( Vec_IntSize(vChamps) == Vec_IntSize(vPathNodes) );
 
     // we have computed the gains - find the best ones
     {
@@ -314,40 +328,118 @@ int Abc_SclFindUpsizes( SC_Man * p, Vec_Int_t * vPathNodes, int Ratio )
         pPerm = Abc_QuickSortCost( Vec_IntArray(vCosts), Vec_IntSize(vCosts), 1 );
         assert( Vec_FltEntry(vSavings, pPerm[0]) >= Vec_FltEntry(vSavings, pPerm[Vec_FltSize(vSavings)-1]) );
         // find those that are good to update
-        Limit = Abc_MaxInt( 1, (int)(0.01 * Ratio * Vec_IntSize(vBests)) ); 
-        vUpdates = Vec_IntAlloc( Limit );
+        Limit = Abc_MaxInt( 1, (int)(0.01 * Ratio * Vec_IntSize(vChamps)) ); 
+        vUpdate = Vec_IntAlloc( Limit );
         for ( i = 0; i < Limit; i++ )
             if ( Vec_FltEntry(vSavings, pPerm[i]) > 0 )
-                Vec_IntPush( vUpdates, pPerm[i] );
+            {
+                assert( Vec_IntEntry(vChamps, pPerm[i]) >= 0 );
+                Vec_IntPush( vUpdate, pPerm[i] );
+            }
         Vec_IntFree( vCosts );
         ABC_FREE( pPerm );
     }
 
     // update the network
-    Vec_IntForEachEntry( vUpdates, Entry, i )
+    Vec_IntForEachEntry( vUpdate, Entry, i )
     {
         // get the object
         pObj = Abc_NtkObj( p->pNtk, Vec_IntEntry(vPathNodes, Entry) );
-        // find new gate
+        assert( pObj->fMarkA );
+        // find old and new gates
         pCellOld = Abc_SclObjCell( p, pObj );
-        pCellNew = SC_LibCell( p->pLib, Vec_IntEntry(vBests, Entry) );
+        pCellNew = SC_LibCell( p->pLib, Vec_IntEntry(vChamps, Entry) );
         assert( pCellNew != NULL );
+//        printf( "%6d  %s -> %s      \n", Abc_ObjId(pObj), pCellOld->pName, pCellNew->pName );
         // update gate
         Abc_SclUpdateLoad( p, pObj, pCellOld, pCellNew );
         p->SumArea += pCellNew->area - pCellOld->area;
         Abc_SclObjSetCell( p, pObj, pCellNew );
-        nUpsizes++;
+        // record the update
+        Vec_IntPush( p->vUpdates, Abc_ObjId(pObj) );
+        Vec_IntPush( p->vUpdates, pCellNew->Id );
     }
 
-    Vec_IntFree( vUpdates );
-    Vec_IntFree( vBests );
+    // cleanup
+    nUpsizes = Vec_IntSize(vUpdate);
+    Vec_IntFree( vUpdate );
+    Vec_IntFree( vChamps );
     Vec_FltFree( vSavings );
     return nUpsizes;
 }
+void Abc_SclApplyUpdateToBest( Vec_Int_t * vGates, Vec_Int_t * vGatesBest, Vec_Int_t * vUpdate )
+{
+    int i, ObjId, GateId, GateId2; 
+    Vec_IntForEachEntryDouble( vUpdate, ObjId, GateId, i )
+        Vec_IntWriteEntry( vGatesBest, ObjId, GateId );
+    Vec_IntClear( vUpdate );
+    Vec_IntForEachEntryTwo( vGates, vGatesBest, GateId, GateId2, i )
+        assert( GateId == GateId2 );
+//printf( "Updating gates.\n" );
+}
 
 
 /**Function*************************************************************
 
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_SclUpsizePrintDiffs( SC_Man * p, SC_Lib * pLib, Abc_Ntk_t * pNtk )
+{
+    float fDiff = (float)0.001;
+    int k;
+    Abc_Obj_t * pObj;
+
+    SC_Pair * pTimes = ABC_ALLOC( SC_Pair, p->nObjs );
+    SC_Pair * pSlews = ABC_ALLOC( SC_Pair, p->nObjs );
+    SC_Pair * pLoads = ABC_ALLOC( SC_Pair, p->nObjs );
+
+    memcpy( pTimes, p->pTimes, sizeof(SC_Pair) * p->nObjs );
+    memcpy( pSlews, p->pSlews, sizeof(SC_Pair) * p->nObjs );
+    memcpy( pLoads, p->pLoads, sizeof(SC_Pair) * p->nObjs );
+
+    Abc_SclTimeNtkRecompute( p, NULL, NULL, 0 );
+
+    Abc_NtkForEachNode( pNtk, pObj, k )
+    {
+        if ( Abc_AbsFloat(p->pLoads[k].rise - pLoads[k].rise) > fDiff )
+            printf( "%6d : load rise differs %12.6f   %f %f\n", k, SC_LibCapFf(pLib, p->pLoads[k].rise)-SC_LibCapFf(pLib, pLoads[k].rise), SC_LibCapFf(pLib, p->pLoads[k].rise), SC_LibCapFf(pLib, pLoads[k].rise) );
+        if ( Abc_AbsFloat(p->pLoads[k].fall - pLoads[k].fall) > fDiff )
+            printf( "%6d : load fall differs %12.6f   %f %f\n", k, SC_LibCapFf(pLib, p->pLoads[k].fall)-SC_LibCapFf(pLib, pLoads[k].fall), SC_LibCapFf(pLib, p->pLoads[k].fall), SC_LibCapFf(pLib, pLoads[k].fall) );
+
+        if ( Abc_AbsFloat(p->pSlews[k].rise - pSlews[k].rise) > fDiff )
+            printf( "%6d : slew rise differs %12.6f   %f %f\n", k, SC_LibTimePs(pLib, p->pSlews[k].rise)-SC_LibTimePs(pLib, pSlews[k].rise), SC_LibTimePs(pLib, p->pSlews[k].rise), SC_LibTimePs(pLib, pSlews[k].rise) );
+        if ( Abc_AbsFloat(p->pSlews[k].fall - pSlews[k].fall) > fDiff )
+            printf( "%6d : slew fall differs %12.6f   %f %f\n", k, SC_LibTimePs(pLib, p->pSlews[k].fall)-SC_LibTimePs(pLib, pSlews[k].fall), SC_LibTimePs(pLib, p->pSlews[k].fall), SC_LibTimePs(pLib, pSlews[k].fall) );
+
+        if ( Abc_AbsFloat(p->pTimes[k].rise - pTimes[k].rise) > fDiff )
+            printf( "%6d : time rise differs %12.6f   %f %f\n", k, SC_LibTimePs(pLib, p->pTimes[k].rise)-SC_LibTimePs(pLib, pTimes[k].rise), SC_LibTimePs(pLib, p->pTimes[k].rise), SC_LibTimePs(pLib, pTimes[k].rise) );
+        if ( Abc_AbsFloat(p->pTimes[k].fall - pTimes[k].fall) > fDiff )
+            printf( "%6d : time fall differs %12.6f   %f %f\n", k, SC_LibTimePs(pLib, p->pTimes[k].fall)-SC_LibTimePs(pLib, pTimes[k].fall), SC_LibTimePs(pLib, p->pTimes[k].fall), SC_LibTimePs(pLib, pTimes[k].fall) );
+    }
+
+/*
+if ( memcmp( pTimes, p->pTimes, sizeof(SC_Pair) * p->nObjs ) )
+    printf( "Times differ!\n" );
+if ( memcmp( pSlews, p->pSlews, sizeof(SC_Pair) * p->nObjs ) )
+    printf( "Slews differ!\n" );
+if ( memcmp( pLoads, p->pLoads, sizeof(SC_Pair) * p->nObjs ) )
+    printf( "Loads differ!\n" );
+*/
+
+    ABC_FREE( pTimes );
+    ABC_FREE( pSlews );
+    ABC_FREE( pLoads );
+}
+
+/**Function*************************************************************
+
   Synopsis    [Print cumulative statistics.]
 
   Description []
@@ -357,20 +449,26 @@ int Abc_SclFindUpsizes( SC_Man * p, Vec_Int_t * vPathNodes, int Ratio )
   SeeAlso     []
 
 ***********************************************************************/
-void Abc_SclUpsizePrint( SC_Man * p, int Iter, Vec_Int_t * vPathPos, Vec_Int_t * vPathNodes, Vec_Int_t * vTFO, int nUpsizes )
+void Abc_SclUpsizePrint( SC_Man * p, int Iter, int nPathPos, int nPathNodes, int nUpsizes, int nTFOs, int fVerbose )
 {
-    printf( "Iter %3d  ",     Iter );
-    printf( "PO:%5d. ",       Vec_IntSize(vPathPos) );
-    printf( "Node:%6d. ",     Vec_IntSize(vPathNodes) );
-    printf( "TFO:%6d. ",      Vec_IntSize(vTFO) );
-    printf( "Size:%5d. ",     nUpsizes );
+    printf( "%4d ",          Iter );
+    printf( "PO:%5d. ",      nPathPos );
+    printf( "Path:%6d. ",    nPathNodes );
+    printf( "Gate:%5d. ",    nUpsizes );
+    printf( "TFO:%6d. ",     nTFOs );
+    printf( "B: " );
+    printf( "%.2f ps ",      SC_LibTimePs(p->pLib, p->BestDelay) );
+    printf( "(%+5.1f %%)  ", 100.0 * (p->BestDelay - p->MaxDelay0)/ p->MaxDelay0 );
     printf( "D: " );
-    printf( "%.2f ps ",       SC_LibTimePs(p->pLib, p->MaxDelay) );
-    printf( "(%+5.1f %%)  ",  100.0 * (p->MaxDelay - p->MaxDelay0)/ p->MaxDelay0 );
+    printf( "%.2f ps ",      SC_LibTimePs(p->pLib, p->MaxDelay) );
+    printf( "(%+5.1f %%)  ", 100.0 * (p->MaxDelay - p->MaxDelay0)/ p->MaxDelay0 );
     printf( "A: " );
-    printf( "%.2f ",          p->SumArea );
-    printf( "(%+5.1f %%)  ",  100.0 * (p->SumArea - p->SumArea0)/ p->SumArea0 );
-    Abc_PrintTime( 1, "Time", clock() - p->clkStart );
+    printf( "%.2f ",         p->SumArea );
+    printf( "(%+5.1f %%)  ", 100.0 * (p->SumArea - p->SumArea0)/ p->SumArea0 );
+    if ( fVerbose )
+        ABC_PRT( "T", clock() - p->timeTotal );
+    else
+        ABC_PRTr( "T", clock() - p->timeTotal );
 }
 
 /**Function*************************************************************
@@ -384,49 +482,102 @@ void Abc_SclUpsizePrint( SC_Man * p, int Iter, Vec_Int_t * vPathPos, Vec_Int_t *
   SeeAlso     []
 
 ***********************************************************************/
-void Abc_SclUpsizePerform( SC_Lib * pLib, Abc_Ntk_t * pNtk, int Window, int Ratio, int nIters, int fVerbose )
+void Abc_SclUpsizePerform( SC_Lib * pLib, Abc_Ntk_t * pNtk, int nIters, int Window, int Ratio, int Notches, int TimeOut, int fVerbose, int fVeryVerbose )
 {
     SC_Man * p;
     Vec_Int_t * vPathPos;    // critical POs
     Vec_Int_t * vPathNodes;  // critical nodes and PIs
     Vec_Int_t * vTFO;
     int i, nUpsizes = -1;
+    int nAllPos, nAllNodes, nAllTfos, nAllUpsizes;
+    clock_t clk;
+
+    if ( fVerbose )
+    {
+        printf( "Sizing parameters: " );
+        printf( "Iters =%4d.  ",            nIters );
+        printf( "Time window =%3d %%.  ",   Window );
+        printf( "Update ratio =%3d %%.  ",  Ratio );
+        printf( "Max upsize steps =%2d.  ", Notches );
+        printf( "Timeout =%3d sec",         TimeOut );
+        printf( "\n" );
+    }
 
     // prepare the manager; collect init stats
     p = Abc_SclManStart( pLib, pNtk, 1 );
+    p->timeTotal  = clock();
+    assert( p->vGatesBest == NULL );
+    p->vGatesBest = Vec_IntDup( p->vGates );
+    p->BestDelay  = p->MaxDelay0;
 
     // perform upsizing
+    nAllPos = nAllNodes = nAllTfos = nAllUpsizes = 0;
     for ( i = 0; nUpsizes && i < nIters; i++ )
     {
+        // detect critical path
+        clk = clock();
         vPathPos   = Abc_SclFindCriticalCoWindow( p, Window );
         vPathNodes = Abc_SclFindCriticalNodeWindow( p, vPathPos, Window );
-        nUpsizes   = Abc_SclFindUpsizes( p, vPathNodes, Ratio );
+        p->timeCone += clock() - clk;
+
+        // selectively upsize the nodes
+        clk = clock();
+        nUpsizes   = Abc_SclFindUpsizes( p, vPathNodes, Ratio, Notches );
+        p->timeSize += clock() - clk;
+
+        // unmark critical path
+        clk = clock();
         Abc_SclUnmarkCriticalNodeWindow( p, vPathNodes );
         Abc_SclUnmarkCriticalNodeWindow( p, vPathPos );
+        p->timeCone += clock() - clk;
 
-        // update info
+        // update timing information
+        clk = clock();
         vTFO = Abc_SclFindTFO( p->pNtk, vPathNodes );
-//        Abc_SclTimeNtkRecompute( p, &p->SumArea, &p->MaxDelay );
-        Abc_SclConeStore( p, vTFO );
         Abc_SclTimeCone( p, vTFO );
+        p->timeTime += clock() - clk;
+//        Abc_SclUpsizePrintDiffs( p, pLib, pNtk );
+
+        // save the best network
         p->MaxDelay = Abc_SclGetMaxDelay( p );
+        if ( p->BestDelay > p->MaxDelay )
+        {
+            p->BestDelay = p->MaxDelay;
+            Abc_SclApplyUpdateToBest( p->vGates, p->vGatesBest, p->vUpdates );
+        }
 
-        Abc_SclUpsizePrint( p, i, vPathPos, vPathNodes, vTFO, nUpsizes );
+        // report and cleanup
+        Abc_SclUpsizePrint( p, i, Vec_IntSize(vPathPos), Vec_IntSize(vPathNodes), nUpsizes, Vec_IntSize(vTFO), fVeryVerbose ); //|| (i == nIters-1) );
+        nAllPos += Vec_IntSize(vPathPos);
+        nAllNodes += Vec_IntSize(vPathNodes);
+        nAllTfos += Vec_IntSize(vTFO);
+        nAllUpsizes += nUpsizes;
         Vec_IntFree( vPathPos );
         Vec_IntFree( vPathNodes );
         Vec_IntFree( vTFO );
-
-        if ( i && i % 50 == 0 )
-            Abc_SclComputeLoad( p );
     }
-//    Abc_NtkCleanMarkAB( pNtk );
+    // update for best gates and recompute timing
+    ABC_SWAP( Vec_Int_t *, p->vGatesBest, p->vGates );
+    if ( fVerbose )
+    {
+        Abc_SclTimeNtkRecompute( p, &p->SumArea, &p->MaxDelay, 0 );
+        Abc_SclUpsizePrint( p, i, nAllPos/i, nAllNodes/i, nAllUpsizes/i, nAllTfos/i, 1 );
+        // report runtime
+        p->timeTotal = clock() - p->timeTotal;
+        p->timeOther = p->timeTotal - p->timeCone - p->timeSize - p->timeTime;
+        ABC_PRTP( "Runtime: Critical path", p->timeCone,  p->timeTotal );
+        ABC_PRTP( "Runtime: Sizing eval  ", p->timeSize,  p->timeTotal );
+        ABC_PRTP( "Runtime: Timing update", p->timeTime,  p->timeTotal );
+        ABC_PRTP( "Runtime: Other        ", p->timeOther, p->timeTotal );
+        ABC_PRTP( "Runtime: TOTAL        ", p->timeTotal, p->timeTotal );
+    }
 
     // save the result and quit
     Abc_SclManSetGates( pLib, pNtk, p->vGates ); // updates gate pointers
     Abc_SclManFree( p );
+//    Abc_NtkCleanMarkAB( pNtk );
 }
 
-
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////