/**CFile**************************************************************** FileName [sclLib.h] SystemName [ABC: Logic synthesis and verification system.] PackageName [Standard-cell library representation.] Synopsis [Simplified library representation for STA.] Author [Alan Mishchenko, Niklas Een] Affiliation [UC Berkeley] Date [Ver. 1.0. Started - August 24, 2012.] Revision [$Id: sclLib.h,v 1.0 2012/08/24 00:00:00 alanmi Exp $] ***********************************************************************/ #ifndef ABC__map__scl__sclLib_h #define ABC__map__scl__sclLib_h //////////////////////////////////////////////////////////////////////// /// INCLUDES /// //////////////////////////////////////////////////////////////////////// #include #include #include #include #include #include "misc/vec/vec.h" ABC_NAMESPACE_HEADER_START //////////////////////////////////////////////////////////////////////// /// PARAMETERS /// //////////////////////////////////////////////////////////////////////// #define ABC_SCL_CUR_VERSION 7 typedef enum { sc_dir_NULL, sc_dir_Input, sc_dir_Output, sc_dir_InOut, sc_dir_Internal, } SC_Dir; typedef enum // -- timing sense, positive-, negative- or non-unate { sc_ts_NULL, sc_ts_Pos, sc_ts_Neg, sc_ts_Non, } SC_TSense; typedef struct SC_Pair_ SC_Pair; struct SC_Pair_ { float rise; float fall; }; typedef struct SC_SizePars_ SC_SizePars; struct SC_SizePars_ { int nIters; int nIterNoChange; int Window; // used for upsizing int Ratio; // used for upsizing int Notches; int DelayUser; int DelayGap; int TimeOut; int BuffTreeEst; // ratio for buffer tree estimation int BypassFreq; // frequency to try bypassing int fUseDept; int fDumpStats; int fUseWireLoads; int fVerbose; int fVeryVerbose; }; typedef struct SC_BusPars_ SC_BusPars; struct SC_BusPars_ { int GainRatio; // target gain int Slew; // target slew int nDegree; // max branching factor int fSizeOnly; // perform only sizing int fAddBufs; // add buffers int fBufPis; // use CI buffering int fUseWireLoads; // wire loads int fVerbose; // verbose int fVeryVerbose; // verbose }; //////////////////////////////////////////////////////////////////////// /// STRUCTURE DEFINITIONS /// //////////////////////////////////////////////////////////////////////// typedef struct SC_WireLoad_ SC_WireLoad; typedef struct SC_WireLoadSel_ SC_WireLoadSel; typedef struct SC_TableTempl_ SC_TableTempl; typedef struct SC_Surface_ SC_Surface; typedef struct SC_Timing_ SC_Timing; typedef struct SC_Timings_ SC_Timings; typedef struct SC_Pin_ SC_Pin; typedef struct SC_Cell_ SC_Cell; typedef struct SC_Lib_ SC_Lib; struct SC_WireLoad_ { char * pName; float cap; // }- multiply estimation in 'fanout_len[].snd' with this value float slope; // used to extrapolate wireload for large fanout count Vec_Int_t * vFanout; // Vec > -- pairs '(#fanouts, est-wire-len)' Vec_Flt_t * vLen; }; struct SC_WireLoadSel_ { char * pName; Vec_Flt_t * vAreaFrom; // Vec > -- triplets '(from-area, upto-area, wire-load-model)'; range is [from, upto[ Vec_Flt_t * vAreaTo; Vec_Ptr_t * vWireLoadModel; }; struct SC_TableTempl_ { char * pName; Vec_Ptr_t * vVars; // Vec -- name of variable (numbered from 0, not 1 as in the Liberty file) Vec_Ptr_t * vIndex; // Vec > -- this is the point of measurement in table for the given variable }; struct SC_Surface_ { char * pName; Vec_Flt_t * vIndex0; // Vec -- correspondes to "index_1" in the liberty file (for timing: slew) Vec_Flt_t * vIndex1; // Vec -- correspondes to "index_2" in the liberty file (for timing: load) Vec_Ptr_t * vData; // Vec > -- 'data[i0][i1]' gives value at '(index0[i0], index1[i1])' float approx[3][6]; }; struct SC_Timing_ { char * related_pin; // -- related pin SC_TSense tsense; // -- timing sense (positive_unate, negative_unate, non_unate) char * when_text; // -- logic condition on inputs triggering this delay model for the output (currently not used) SC_Surface * pCellRise; // -- Used to compute pin-to-pin delay SC_Surface * pCellFall; SC_Surface * pRiseTrans; // -- Used to compute output slew SC_Surface * pFallTrans; }; struct SC_Timings_ { char * pName; // -- the 'related_pin' field Vec_Ptr_t * vTimings; // structures of type SC_Timing }; struct SC_Pin_ { char * pName; SC_Dir dir; float cap; // -- this value is used if 'rise_cap' and 'fall_cap' is missing (copied by 'postProcess()'). (not used) float rise_cap; // }- used for input pins ('cap' too). float fall_cap; // } float max_out_cap; // } (not used) float max_out_slew; // }- used only for output pins (max values must not be exceeded or else mapping is illegal) (not used) char * func_text; // } Vec_Wrd_t * vFunc; // } Vec_Ptr_t * vRTimings; // -- for output pins }; struct SC_Cell_ { char * pName; int Id; int fSkip; // skip this cell during genlib computation int seq; // -- set to TRUE by parser if a sequential element int unsupp; // -- set to TRUE by parser if cell contains information we cannot handle float area; int drive_strength; // -- some library files provide this field (currently unused, but may be a good hint for sizing) (not used) Vec_Ptr_t * vPins; // NamedSet int n_inputs; // -- 'pins[0 .. n_inputs-1]' are input pins int n_outputs; // -- 'pins[n_inputs .. n_inputs+n_outputs-1]' are output pins SC_Cell * pNext; // same-functionality cells linked into a ring by area SC_Cell * pPrev; // same-functionality cells linked into a ring by area SC_Cell * pRepr; // representative of the class SC_Cell * pAve; // average size cell of this class int Order; // order of the gate in the list int nGates; // the number of gates in the list }; struct SC_Lib_ { char * pName; char * pFileName; char * default_wire_load; char * default_wire_load_sel; float default_max_out_slew; // -- 'default_max_transition'; this is copied to each output pin where 'max_transition' is not defined (not used) int unit_time; // -- Valid 9..12. Unit is '10^(-val)' seconds (e.g. 9=1ns, 10=100ps, 11=10ps, 12=1ps) float unit_cap_fst; // -- First part is a multiplier, second either 12 or 15 for 'pf' or 'ff'. int unit_cap_snd; Vec_Ptr_t * vWireLoads; // NamedSet Vec_Ptr_t * vWireLoadSels; // NamedSet Vec_Ptr_t * vTempls; // NamedSet Vec_Ptr_t * vCells; // NamedSet Vec_Ptr_t * vCellClasses; // NamedSet int * pBins; // hashing gateName -> gateId int nBins; }; //////////////////////////////////////////////////////////////////////// /// GLOBAL VARIABLES /// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// MACRO DEFINITIONS /// //////////////////////////////////////////////////////////////////////// static inline void SC_PairClean( SC_Pair * d ) { d->rise = d->fall = 0; } static inline float SC_PairMax( SC_Pair * d ) { return Abc_MaxFloat(d->rise, d->fall); } static inline float SC_PairMin( SC_Pair * d ) { return Abc_MinFloat(d->rise, d->fall); } static inline float SC_PairAve( SC_Pair * d ) { return 0.5 * d->rise + 0.5 * d->fall; } static inline void SC_PairDup( SC_Pair * d, SC_Pair * s ) { *d = *s; } static inline void SC_PairMove( SC_Pair * d, SC_Pair * s ) { *d = *s; s->rise = s->fall = 0; } static inline int SC_PairEqual( SC_Pair * d, SC_Pair * s ) { return d->rise == s->rise && d->fall == s->fall; } static inline int SC_PairEqualE( SC_Pair * d, SC_Pair * s, float E ) { return d->rise - s->rise < E && s->rise - d->rise < E && d->fall - s->fall < E && s->fall - d->fall < E; } static inline int SC_LibCellNum( SC_Lib * p ) { return Vec_PtrSize(p->vCells); } static inline SC_Cell * SC_LibCell( SC_Lib * p, int i ) { return (SC_Cell *)Vec_PtrEntry(p->vCells, i); } static inline SC_Pin * SC_CellPin( SC_Cell * p, int i ) { return (SC_Pin *)Vec_PtrEntry(p->vPins, i); } static inline Vec_Wrd_t * SC_CellFunc( SC_Cell * p ) { return SC_CellPin(p, p->n_inputs)->vFunc; } static inline float SC_CellPinCap( SC_Cell * p, int i ) { return 0.5 * SC_CellPin(p, i)->rise_cap + 0.5 * SC_CellPin(p, i)->fall_cap; } static inline float SC_CellPinCapAve( SC_Cell * p ) { int i; float c = 0; for (i = 0; i < p->n_inputs; i++) c += SC_CellPinCap(p, i); return c / Abc_MaxInt(1, p->n_inputs); } static inline char * SC_CellPinOutFunc( SC_Cell * p, int i ) { return SC_CellPin(p, p->n_inputs + i)->func_text; } static inline char * SC_CellPinName( SC_Cell * p, int i ) { return SC_CellPin(p, i)->pName; } #define SC_LibForEachCell( p, pCell, i ) Vec_PtrForEachEntry( SC_Cell *, p->vCells, pCell, i ) #define SC_LibForEachCellClass( p, pCell, i ) Vec_PtrForEachEntry( SC_Cell *, p->vCellClasses, pCell, i ) #define SC_LibForEachWireLoad( p, pWL, i ) Vec_PtrForEachEntry( SC_WireLoad *, p->vWireLoads, pWL, i ) #define SC_LibForEachWireLoadSel( p, pWLS, i ) Vec_PtrForEachEntry( SC_WireLoadSel *, p->vWireLoadSels, pWLS, i ) #define SC_LibForEachTempl( p, pTempl, i ) Vec_PtrForEachEntry( SC_TableTempl *, p->vTempls, pTempl, i ) #define SC_CellForEachPin( p, pPin, i ) Vec_PtrForEachEntry( SC_Pin *, p->vPins, pPin, i ) #define SC_CellForEachPinIn( p, pPin, i ) Vec_PtrForEachEntryStop( SC_Pin *, p->vPins, pPin, i, p->n_inputs ) #define SC_CellForEachPinOut( p, pPin, i ) Vec_PtrForEachEntryStart( SC_Pin *, p->vPins, pPin, i, p->n_inputs ) #define SC_RingForEachCell( pRing, pCell, i ) for ( i = 0, pCell = pRing; i == 0 || pCell != pRing; pCell = pCell->pNext, i++ ) #define SC_RingForEachCellRev( pRing, pCell, i ) for ( i = 0, pCell = pRing; i == 0 || pCell != pRing; pCell = pCell->pPrev, i++ ) #define SC_PinForEachRTiming( p, pRTime, i ) Vec_PtrForEachEntry( SC_Timings *, p->vRTimings, pRTime, i ) //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [Constructors of the library data-structures.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline SC_WireLoad * Abc_SclWireLoadAlloc() { SC_WireLoad * p; p = ABC_CALLOC( SC_WireLoad, 1 ); p->vFanout = Vec_IntAlloc( 0 ); p->vLen = Vec_FltAlloc( 0 ); return p; } static inline SC_WireLoadSel * Abc_SclWireLoadSelAlloc() { SC_WireLoadSel * p; p = ABC_CALLOC( SC_WireLoadSel, 1 ); p->vAreaFrom = Vec_FltAlloc( 0 ); p->vAreaTo = Vec_FltAlloc( 0 ); p->vWireLoadModel = Vec_PtrAlloc( 0 ); return p; } static inline SC_TableTempl * Abc_SclTableTemplAlloc() { SC_TableTempl * p; p = ABC_CALLOC( SC_TableTempl, 1 ); p->vVars = Vec_PtrAlloc( 0 ); p->vIndex = Vec_PtrAlloc( 0 ); return p; } static inline SC_Surface * Abc_SclSurfaceAlloc() { SC_Surface * p; p = ABC_CALLOC( SC_Surface, 1 ); p->vIndex0 = Vec_FltAlloc( 0 ); p->vIndex1 = Vec_FltAlloc( 0 ); p->vData = Vec_PtrAlloc( 0 ); return p; } static inline SC_Timing * Abc_SclTimingAlloc() { SC_Timing * p; p = ABC_CALLOC( SC_Timing, 1 ); p->pCellRise = Abc_SclSurfaceAlloc(); p->pCellFall = Abc_SclSurfaceAlloc(); p->pRiseTrans = Abc_SclSurfaceAlloc(); p->pFallTrans = Abc_SclSurfaceAlloc(); return p; } static inline SC_Timings * Abc_SclTimingsAlloc() { SC_Timings * p; p = ABC_CALLOC( SC_Timings, 1 ); p->vTimings = Vec_PtrAlloc( 0 ); return p; } static inline SC_Pin * Abc_SclPinAlloc() { SC_Pin * p; p = ABC_CALLOC( SC_Pin, 1 ); p->max_out_slew = -1; p->vFunc = Vec_WrdAlloc( 0 ); p->vRTimings = Vec_PtrAlloc( 0 ); return p; } static inline SC_Cell * Abc_SclCellAlloc() { SC_Cell * p; p = ABC_CALLOC( SC_Cell, 1 ); p->vPins = Vec_PtrAlloc( 0 ); return p; } static inline SC_Lib * Abc_SclLibAlloc() { SC_Lib * p; p = ABC_CALLOC( SC_Lib, 1 ); p->default_max_out_slew = -1; p->unit_time = 9; p->unit_cap_fst = 1; p->unit_cap_snd = 12; p->vWireLoads = Vec_PtrAlloc( 0 ); p->vWireLoadSels = Vec_PtrAlloc( 0 ); p->vTempls = Vec_PtrAlloc( 0 ); p->vCells = Vec_PtrAlloc( 0 ); p->vCellClasses = Vec_PtrAlloc( 0 ); return p; } /**Function************************************************************* Synopsis [Destructors of the library data-structures.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Abc_SclWireLoadFree( SC_WireLoad * p ) { Vec_IntFree( p->vFanout ); Vec_FltFree( p->vLen ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclWireLoadSelFree( SC_WireLoadSel * p ) { Vec_FltFree( p->vAreaFrom ); Vec_FltFree( p->vAreaTo ); Vec_PtrFreeFree( p->vWireLoadModel ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclTableTemplFree( SC_TableTempl * p ) { Vec_PtrFreeFree( p->vVars ); Vec_VecFree( (Vec_Vec_t *)p->vIndex ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclSurfaceFree( SC_Surface * p ) { Vec_FltFree( p->vIndex0 ); Vec_FltFree( p->vIndex1 ); Vec_VecFree( (Vec_Vec_t *)p->vData ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclTimingFree( SC_Timing * p ) { Abc_SclSurfaceFree( p->pCellRise ); Abc_SclSurfaceFree( p->pCellFall ); Abc_SclSurfaceFree( p->pRiseTrans ); Abc_SclSurfaceFree( p->pFallTrans ); ABC_FREE( p->related_pin ); ABC_FREE( p->when_text ); ABC_FREE( p ); } static inline void Abc_SclTimingsFree( SC_Timings * p ) { SC_Timing * pTemp; int i; Vec_PtrForEachEntry( SC_Timing *, p->vTimings, pTemp, i ) Abc_SclTimingFree( pTemp ); Vec_PtrFree( p->vTimings ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclPinFree( SC_Pin * p ) { SC_Timings * pTemp; int i; SC_PinForEachRTiming( p, pTemp, i ) Abc_SclTimingsFree( pTemp ); Vec_PtrFree( p->vRTimings ); Vec_WrdFree( p->vFunc ); ABC_FREE( p->func_text ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclCellFree( SC_Cell * p ) { SC_Pin * pTemp; int i; SC_CellForEachPin( p, pTemp, i ) Abc_SclPinFree( pTemp ); Vec_PtrFree( p->vPins ); ABC_FREE( p->pName ); ABC_FREE( p ); } static inline void Abc_SclLibFree( SC_Lib * p ) { SC_WireLoad * pWL; SC_WireLoadSel * pWLS; SC_TableTempl * pTempl; SC_Cell * pCell; int i; SC_LibForEachWireLoad( p, pWL, i ) Abc_SclWireLoadFree( pWL ); Vec_PtrFree( p->vWireLoads ); SC_LibForEachWireLoadSel( p, pWLS, i ) Abc_SclWireLoadSelFree( pWLS ); Vec_PtrFree( p->vWireLoadSels ); SC_LibForEachTempl( p, pTempl, i ) Abc_SclTableTemplFree( pTempl ); Vec_PtrFree( p->vTempls ); SC_LibForEachCell( p, pCell, i ) Abc_SclCellFree( pCell ); Vec_PtrFree( p->vCells ); Vec_PtrFree( p->vCellClasses ); ABC_FREE( p->pName ); ABC_FREE( p->pFileName ); ABC_FREE( p->default_wire_load ); ABC_FREE( p->default_wire_load_sel ); ABC_FREE( p->pBins ); ABC_FREE( p ); } /**Function************************************************************* Synopsis [Lookup table delay computation.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline float Scl_LibLookup( SC_Surface * p, float slew, float load ) { float * pIndex0, * pIndex1, * pDataS, * pDataS1; float sfrac, lfrac, p0, p1; int s, l; // handle constant table if ( Vec_FltSize(p->vIndex0) == 1 && Vec_FltSize(p->vIndex1) == 1 ) { Vec_Flt_t * vTemp = (Vec_Flt_t *)Vec_PtrEntry(p->vData, 0); assert( Vec_PtrSize(p->vData) == 1 ); assert( Vec_FltSize(vTemp) == 1 ); return Vec_FltEntry(vTemp, 0); } // Find closest sample points in surface: pIndex0 = Vec_FltArray(p->vIndex0); for ( s = 1; s < Vec_FltSize(p->vIndex0)-1; s++ ) if ( pIndex0[s] > slew ) break; s--; pIndex1 = Vec_FltArray(p->vIndex1); for ( l = 1; l < Vec_FltSize(p->vIndex1)-1; l++ ) if ( pIndex1[l] > load ) break; l--; // Interpolate (or extrapolate) function value from sample points: sfrac = (slew - pIndex0[s]) / (pIndex0[s+1] - pIndex0[s]); lfrac = (load - pIndex1[l]) / (pIndex1[l+1] - pIndex1[l]); pDataS = Vec_FltArray( (Vec_Flt_t *)Vec_PtrEntry(p->vData, s) ); pDataS1 = Vec_FltArray( (Vec_Flt_t *)Vec_PtrEntry(p->vData, s+1) ); p0 = pDataS [l] + lfrac * (pDataS [l+1] - pDataS [l]); p1 = pDataS1[l] + lfrac * (pDataS1[l+1] - pDataS1[l]); return p0 + sfrac * (p1 - p0); // <<== multiply result with K factor here } static inline void Scl_LibPinArrival( SC_Timing * pTime, SC_Pair * pArrIn, SC_Pair * pSlewIn, SC_Pair * pLoad, SC_Pair * pArrOut, SC_Pair * pSlewOut ) { if (pTime->tsense == sc_ts_Pos || pTime->tsense == sc_ts_Non) { pArrOut->rise = Abc_MaxFloat( pArrOut->rise, pArrIn->rise + Scl_LibLookup(pTime->pCellRise, pSlewIn->rise, pLoad->rise) ); pArrOut->fall = Abc_MaxFloat( pArrOut->fall, pArrIn->fall + Scl_LibLookup(pTime->pCellFall, pSlewIn->fall, pLoad->fall) ); pSlewOut->rise = Abc_MaxFloat( pSlewOut->rise, Scl_LibLookup(pTime->pRiseTrans, pSlewIn->rise, pLoad->rise) ); pSlewOut->fall = Abc_MaxFloat( pSlewOut->fall, Scl_LibLookup(pTime->pFallTrans, pSlewIn->fall, pLoad->fall) ); } if (pTime->tsense == sc_ts_Neg || pTime->tsense == sc_ts_Non) { pArrOut->rise = Abc_MaxFloat( pArrOut->rise, pArrIn->fall + Scl_LibLookup(pTime->pCellRise, pSlewIn->fall, pLoad->rise) ); pArrOut->fall = Abc_MaxFloat( pArrOut->fall, pArrIn->rise + Scl_LibLookup(pTime->pCellFall, pSlewIn->rise, pLoad->fall) ); pSlewOut->rise = Abc_MaxFloat( pSlewOut->rise, Scl_LibLookup(pTime->pRiseTrans, pSlewIn->fall, pLoad->rise) ); pSlewOut->fall = Abc_MaxFloat( pSlewOut->fall, Scl_LibLookup(pTime->pFallTrans, pSlewIn->rise, pLoad->fall) ); } } static inline void Scl_LibPinDeparture( SC_Timing * pTime, SC_Pair * pDepIn, SC_Pair * pSlewIn, SC_Pair * pLoad, SC_Pair * pDepOut ) { if (pTime->tsense == sc_ts_Pos || pTime->tsense == sc_ts_Non) { pDepIn->rise = Abc_MaxFloat( pDepIn->rise, pDepOut->rise + Scl_LibLookup(pTime->pCellRise, pSlewIn->rise, pLoad->rise) ); pDepIn->fall = Abc_MaxFloat( pDepIn->fall, pDepOut->fall + Scl_LibLookup(pTime->pCellFall, pSlewIn->fall, pLoad->fall) ); } if (pTime->tsense == sc_ts_Neg || pTime->tsense == sc_ts_Non) { pDepIn->fall = Abc_MaxFloat( pDepIn->fall, pDepOut->rise + Scl_LibLookup(pTime->pCellRise, pSlewIn->fall, pLoad->rise) ); pDepIn->rise = Abc_MaxFloat( pDepIn->rise, pDepOut->fall + Scl_LibLookup(pTime->pCellFall, pSlewIn->rise, pLoad->fall) ); } } /**Function************************************************************* Synopsis [Compute one timing edge.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline SC_Timing * Scl_CellPinTime( SC_Cell * pCell, int iPin ) { SC_Pin * pPin; SC_Timings * pRTime; assert( iPin >= 0 && iPin < pCell->n_inputs ); pPin = SC_CellPin( pCell, pCell->n_inputs ); assert( Vec_PtrSize(pPin->vRTimings) == pCell->n_inputs ); pRTime = (SC_Timings *)Vec_PtrEntry( pPin->vRTimings, iPin ); if ( Vec_PtrSize(pRTime->vTimings) == 0 ) return NULL; assert( Vec_PtrSize(pRTime->vTimings) == 1 ); return (SC_Timing *)Vec_PtrEntry( pRTime->vTimings, 0 ); } static inline float Scl_LibPinArrivalEstimate( SC_Cell * pCell, int iPin, float Slew, float Load ) { SC_Pair LoadIn = { Load, Load }; SC_Pair ArrIn = { 0.0, 0.0 }; SC_Pair ArrOut = { 0.0, 0.0 }; SC_Pair SlewIn = { 0.0, 0.0 }; SC_Pair SlewOut = { 0.0, 0.0 }; // Vec_Flt_t * vIndex0 = pTime->pCellRise->vIndex0; // slew // SlewIn.fall = SlewIn.rise = Vec_FltEntry( vIndex0, Vec_FltSize(vIndex0)/2 ); SlewIn.fall = SlewIn.rise = Slew; Scl_LibPinArrival( Scl_CellPinTime(pCell, iPin), &ArrIn, &SlewIn, &LoadIn, &ArrOut, &SlewOut ); return 0.5 * ArrOut.fall + 0.5 * ArrOut.rise; } static inline void Scl_LibHandleInputDriver( SC_Cell * pCell, SC_Pair * pLoadIn, SC_Pair * pArrOut, SC_Pair * pSlewOut ) { SC_Pair LoadIn = { 0.0, 0.0 }; // zero input load SC_Pair ArrIn = { 0.0, 0.0 }; // zero input time SC_Pair SlewIn = { 0.0, 0.0 }; // zero input slew SC_Pair ArrOut0 = { 0.0, 0.0 }; // output time under zero load SC_Pair ArrOut1 = { 0.0, 0.0 }; // output time under given load SC_Pair SlewOut = { 0.0, 0.0 }; // output slew under zero load pSlewOut->fall = pSlewOut->rise = 0; assert( pCell->n_inputs == 1 ); Scl_LibPinArrival( Scl_CellPinTime(pCell, 0), &ArrIn, &SlewIn, &LoadIn, &ArrOut0, &SlewOut ); Scl_LibPinArrival( Scl_CellPinTime(pCell, 0), &ArrIn, &SlewIn, pLoadIn, &ArrOut1, pSlewOut ); pArrOut->fall = ArrOut1.fall - ArrOut0.fall; pArrOut->rise = ArrOut1.rise - ArrOut0.rise; } /*=== sclLiberty.c ===============================================================*/ extern SC_Lib * Abc_SclReadLiberty( char * pFileName, int fVerbose, int fVeryVerbose ); /*=== sclLibScl.c ===============================================================*/ extern SC_Lib * Abc_SclReadFromStr( Vec_Str_t * vOut ); extern SC_Lib * Abc_SclReadFromFile( char * pFileName ); extern void Abc_SclWriteScl( char * pFileName, SC_Lib * p ); extern void Abc_SclWriteLiberty( char * pFileName, SC_Lib * p ); /*=== sclLibUtil.c ===============================================================*/ extern void Abc_SclHashCells( SC_Lib * p ); extern int Abc_SclCellFind( SC_Lib * p, char * pName ); extern int Abc_SclClassCellNum( SC_Cell * pClass ); extern int Abc_SclLibClassNum( SC_Lib * pLib ); extern void Abc_SclLinkCells( SC_Lib * p ); extern void Abc_SclPrintCells( SC_Lib * p, float Slew, float Gain, int fInvOnly, int fShort ); extern void Abc_SclLibNormalize( SC_Lib * p ); extern SC_Cell * Abc_SclFindInvertor( SC_Lib * p, int fFindBuff ); extern SC_Cell * Abc_SclFindSmallestGate( SC_Cell * p, float CinMin ); extern SC_WireLoad * Abc_SclFindWireLoadModel( SC_Lib * p, float Area ); extern SC_WireLoad * Abc_SclFetchWireLoadModel( SC_Lib * p, char * pName ); extern int Abc_SclHasDelayInfo( void * pScl ); extern float Abc_SclComputeAverageSlew( SC_Lib * p ); extern void Abc_SclDumpGenlib( char * pFileName, SC_Lib * p, float Slew, float Gain, int nGatesMin ); extern void Abc_SclInstallGenlib( void * pScl, float Slew, float Gain, int nGatesMin ); ABC_NAMESPACE_HEADER_END #endif //////////////////////////////////////////////////////////////////////// /// END OF FILE /// ////////////////////////////////////////////////////////////////////////