From 9206e6ff80e56c810814a9b9f61e45be8c4c4987 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Mon, 8 Oct 2012 21:20:13 -0700 Subject: Improvements to gate sizing. --- src/map/scl/sclUpsize.c | 329 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 240 insertions(+), 89 deletions(-) (limited to 'src/map/scl/sclUpsize.c') 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,38 +328,116 @@ 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.] @@ -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 /// //////////////////////////////////////////////////////////////////////// -- cgit v1.2.3