sclLib.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include "misc/vec/vec.h"

Go to the source code of this file.

Data Structures
struct	SC_Pair_
struct	SC_SizePars_
struct	SC_BusPars_
struct	SC_WireLoad_
struct	SC_WireLoadSel_
struct	SC_TableTempl_
struct	SC_Surface_
struct	SC_Timing_
struct	SC_Timings_
struct	SC_Pin_
struct	SC_Cell_
struct	SC_Lib_

Macros
#define	ABC_SCL_CUR_VERSION   8
	INCLUDES ///. More...
#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 )

Typedefs
typedef struct SC_Pair_	SC_Pair
typedef struct SC_SizePars_	SC_SizePars
typedef struct SC_BusPars_	SC_BusPars
typedef struct SC_WireLoad_	SC_WireLoad
	STRUCTURE DEFINITIONS ///. More...
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

Enumerations
enum	SC_Dir {   sc_dir_NULL, sc_dir_Input, sc_dir_Output, sc_dir_InOut,   sc_dir_Internal }
enum	SC_TSense { sc_ts_NULL, sc_ts_Pos, sc_ts_Neg, sc_ts_Non }

Functions
static void	SC_PairClean (SC_Pair *d)
	GLOBAL VARIABLES ///. More...
static float	SC_PairMax (SC_Pair *d)
static float	SC_PairMin (SC_Pair *d)
static float	SC_PairAve (SC_Pair *d)
static void	SC_PairDup (SC_Pair *d, SC_Pair *s)
static void	SC_PairMove (SC_Pair *d, SC_Pair *s)
static void	SC_PairAdd (SC_Pair *d, SC_Pair *s)
static int	SC_PairEqual (SC_Pair *d, SC_Pair *s)
static int	SC_PairEqualE (SC_Pair *d, SC_Pair *s, float E)
static int	SC_LibCellNum (SC_Lib *p)
static SC_Cell *	SC_LibCell (SC_Lib *p, int i)
static SC_Pin *	SC_CellPin (SC_Cell *p, int i)
static Vec_Wrd_t *	SC_CellFunc (SC_Cell *p)
static float	SC_CellPinCap (SC_Cell *p, int i)
static float	SC_CellPinCapAve (SC_Cell *p)
static char *	SC_CellPinOutFunc (SC_Cell *p, int i)
static char *	SC_CellPinName (SC_Cell *p, int i)
static SC_WireLoad *	Abc_SclWireLoadAlloc ()
	FUNCTION DEFINITIONS ///. More...
static SC_WireLoadSel *	Abc_SclWireLoadSelAlloc ()
static SC_TableTempl *	Abc_SclTableTemplAlloc ()
static SC_Surface *	Abc_SclSurfaceAlloc ()
static SC_Timing *	Abc_SclTimingAlloc ()
static SC_Timings *	Abc_SclTimingsAlloc ()
static SC_Pin *	Abc_SclPinAlloc ()
static SC_Cell *	Abc_SclCellAlloc ()
static SC_Lib *	Abc_SclLibAlloc ()
static void	Abc_SclWireLoadFree (SC_WireLoad *p)
static void	Abc_SclWireLoadSelFree (SC_WireLoadSel *p)
static void	Abc_SclTableTemplFree (SC_TableTempl *p)
static void	Abc_SclSurfaceFree (SC_Surface *p)
static void	Abc_SclTimingFree (SC_Timing *p)
static void	Abc_SclTimingsFree (SC_Timings *p)
static void	Abc_SclPinFree (SC_Pin *p)
static void	Abc_SclCellFree (SC_Cell *p)
static void	Abc_SclLibFree (SC_Lib *p)
static float	Scl_LibLookup (SC_Surface *p, float slew, float load)
static void	Scl_LibPinArrival (SC_Timing *pTime, SC_Pair *pArrIn, SC_Pair *pSlewIn, SC_Pair *pLoad, SC_Pair *pArrOut, SC_Pair *pSlewOut)
static void	Scl_LibPinDeparture (SC_Timing *pTime, SC_Pair *pDepIn, SC_Pair *pSlewIn, SC_Pair *pLoad, SC_Pair *pDepOut)
static SC_Timing *	Scl_CellPinTime (SC_Cell *pCell, int iPin)
static float	Scl_LibPinArrivalEstimate (SC_Cell *pCell, int iPin, float Slew, float Load)
static void	Scl_LibHandleInputDriver (SC_Cell *pCell, SC_Pair *pLoadIn, SC_Pair *pArrOut, SC_Pair *pSlewOut)
SC_Lib *	Abc_SclReadLiberty (char *pFileName, int fVerbose, int fVeryVerbose)
SC_Lib *	Abc_SclReadFromStr (Vec_Str_t *vOut)
SC_Lib *	Abc_SclReadFromFile (char *pFileName)
void	Abc_SclWriteScl (char *pFileName, SC_Lib *p)
void	Abc_SclWriteLiberty (char *pFileName, SC_Lib *p)
void	Abc_SclHashCells (SC_Lib *p)
int	Abc_SclCellFind (SC_Lib *p, char *pName)
int	Abc_SclClassCellNum (SC_Cell *pClass)
int	Abc_SclLibClassNum (SC_Lib *pLib)
void	Abc_SclLinkCells (SC_Lib *p)
void	Abc_SclPrintCells (SC_Lib *p, float Slew, float Gain, int fInvOnly, int fShort)
void	Abc_SclConvertLeakageIntoArea (SC_Lib *p, float A, float B)
void	Abc_SclLibNormalize (SC_Lib *p)
SC_Cell *	Abc_SclFindInvertor (SC_Lib *p, int fFindBuff)
SC_Cell *	Abc_SclFindSmallestGate (SC_Cell *p, float CinMin)
SC_WireLoad *	Abc_SclFindWireLoadModel (SC_Lib *p, float Area)
SC_WireLoad *	Abc_SclFetchWireLoadModel (SC_Lib *p, char *pName)
int	Abc_SclHasDelayInfo (void *pScl)
float	Abc_SclComputeAverageSlew (SC_Lib *p)
void	Abc_SclDumpGenlib (char *pFileName, SC_Lib *p, float Slew, float Gain, int nGatesMin)
void	Abc_SclInstallGenlib (void *pScl, float Slew, float Gain, int nGatesMin)

Macro Definition Documentation

#define ABC_SCL_CUR_VERSION   8

INCLUDES ///.

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

]PARAMETERS ///

Definition at line 43 of file sclLib.h.

#define SC_CellForEachPin	(		p,
			pPin,
			i
	)		Vec_PtrForEachEntry( SC_Pin *, p->vPins, pPin, i )

Definition at line 253 of file sclLib.h.

#define SC_CellForEachPinIn	(		p,
			pPin,
			i
	)		Vec_PtrForEachEntryStop( SC_Pin *, p->vPins, pPin, i, p->n_inputs )

Definition at line 254 of file sclLib.h.

#define SC_CellForEachPinOut	(		p,
			pPin,
			i
	)		Vec_PtrForEachEntryStart( SC_Pin *, p->vPins, pPin, i, p->n_inputs )

Definition at line 255 of file sclLib.h.

#define SC_LibForEachCell	(		p,
			pCell,
			i
	)		Vec_PtrForEachEntry( SC_Cell *, p->vCells, pCell, i )

Definition at line 248 of file sclLib.h.

#define SC_LibForEachCellClass	(		p,
			pCell,
			i
	)		Vec_PtrForEachEntry( SC_Cell *, p->vCellClasses, pCell, i )

Definition at line 249 of file sclLib.h.

#define SC_LibForEachTempl	(		p,
			pTempl,
			i
	)		Vec_PtrForEachEntry( SC_TableTempl *, p->vTempls, pTempl, i )

Definition at line 252 of file sclLib.h.

#define SC_LibForEachWireLoad	(		p,
			pWL,
			i
	)		Vec_PtrForEachEntry( SC_WireLoad *, p->vWireLoads, pWL, i )

Definition at line 250 of file sclLib.h.

#define SC_LibForEachWireLoadSel	(		p,
			pWLS,
			i
	)		Vec_PtrForEachEntry( SC_WireLoadSel *, p->vWireLoadSels, pWLS, i )

Definition at line 251 of file sclLib.h.

#define SC_PinForEachRTiming	(		p,
			pRTime,
			i
	)		Vec_PtrForEachEntry( SC_Timings *, p->vRTimings, pRTime, i )

Definition at line 258 of file sclLib.h.

#define SC_RingForEachCell	(		pRing,
			pCell,
			i
	)		for ( i = 0, pCell = pRing; i == 0 || pCell != pRing; pCell = pCell->pNext, i++ )

Definition at line 256 of file sclLib.h.

#define SC_RingForEachCellRev	(		pRing,
			pCell,
			i
	)		for ( i = 0, pCell = pRing; i == 0 || pCell != pRing; pCell = pCell->pPrev, i++ )

Definition at line 257 of file sclLib.h.

Typedef Documentation

typedef struct SC_BusPars_ SC_BusPars

Definition at line 89 of file sclLib.h.

typedef struct SC_Cell_ SC_Cell

Definition at line 114 of file sclLib.h.

typedef struct SC_Lib_ SC_Lib

Definition at line 115 of file sclLib.h.

typedef struct SC_Pair_ SC_Pair

Definition at line 62 of file sclLib.h.

typedef struct SC_Pin_ SC_Pin

Definition at line 113 of file sclLib.h.

typedef struct SC_SizePars_ SC_SizePars

Definition at line 69 of file sclLib.h.

typedef struct SC_Surface_ SC_Surface

Definition at line 110 of file sclLib.h.

typedef struct SC_TableTempl_ SC_TableTempl

Definition at line 109 of file sclLib.h.

typedef struct SC_Timing_ SC_Timing

Definition at line 111 of file sclLib.h.

typedef struct SC_Timings_ SC_Timings

Definition at line 112 of file sclLib.h.

typedef struct SC_WireLoad_ SC_WireLoad

STRUCTURE DEFINITIONS ///.

Definition at line 107 of file sclLib.h.

typedef struct SC_WireLoadSel_ SC_WireLoadSel

Definition at line 108 of file sclLib.h.

Enumeration Type Documentation

enum SC_Dir

Enumerator
sc_dir_NULL
sc_dir_Input
sc_dir_Output
sc_dir_InOut
sc_dir_Internal

Definition at line 45 of file sclLib.h.

{
    sc_dir_NULL,
    sc_dir_Input,
    sc_dir_Output,
    sc_dir_InOut,
    sc_dir_Internal,
} SC_Dir;

enum SC_TSense

Enumerator
sc_ts_NULL
sc_ts_Pos
sc_ts_Neg
sc_ts_Non

Definition at line 54 of file sclLib.h.

{
    sc_ts_NULL,
    sc_ts_Pos,
    sc_ts_Neg,
    sc_ts_Non,
} SC_TSense;

Function Documentation

static SC_Cell* Abc_SclCellAlloc ( )

inlinestatic

Definition at line 336 of file sclLib.h.

{
    SC_Cell * p;
    p = ABC_CALLOC( SC_Cell, 1 );
    p->vPins = Vec_PtrAlloc( 0 );
    return p;
}

int Abc_SclCellFind	(	SC_Lib *	p,
		char *	pName
	)

Definition at line 79 of file sclLibUtil.c.

{
    int *pPlace = Abc_SclHashLookup( p, pName );
    return pPlace ? *pPlace : -1;
}

static void Abc_SclCellFree ( SC_Cell *  p )

inlinestatic

Definition at line 433 of file sclLib.h.

{
    SC_Pin * pTemp;
    int i;
    SC_CellForEachPin( p, pTemp, i )
        Abc_SclPinFree( pTemp );
    Vec_PtrFree( p->vPins );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

int Abc_SclClassCellNum

(

SC_Cell *

pClass

)

Definition at line 84 of file sclLibUtil.c.

{
    SC_Cell * pCell;
    int i, Count = 0;
    SC_RingForEachCell( pClass, pCell, i )
        if ( !pCell->fSkip )
            Count++;
    return Count;
}

float Abc_SclComputeAverageSlew

(

SC_Lib *

p

)

Function*************************************************************

Synopsis [Returns "average" slew.]

Description []

SideEffects []

SeeAlso []

Definition at line 317 of file sclLibUtil.c.

{
    SC_Cell * pCell;
    SC_Timing * pTime;
    Vec_Flt_t * vIndex;
    pCell = Abc_SclFindInvertor(p, 0);
    if ( pCell == NULL )
        return 0;
    pTime = Scl_CellPinTime( pCell, 0 );
    if ( pTime == NULL )
        return 0;
    vIndex = pTime->pCellRise->vIndex0; // slew
    return Vec_FltEntry( vIndex, Vec_FltSize(vIndex)/3 );
}

void Abc_SclConvertLeakageIntoArea	(	SC_Lib *	p,
		float	A,
		float	B
	)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 584 of file sclLibUtil.c.

{
    SC_Cell * pCell; int i;
    SC_LibForEachCell( p, pCell, i )
        pCell->area = A * pCell->area + B * pCell->leakage;
}

void Abc_SclDumpGenlib	(	char *	pFileName,
		SC_Lib *	p,
		float	Slew,
		float	Gain,
		int	nGatesMin
	)

Definition at line 795 of file sclLibUtil.c.

{
    int nCellCount = 0;
    char FileName[1000];
    float Slew = (SlewInit == 0) ? Abc_SclComputeAverageSlew(p) : SlewInit;
    Vec_Str_t * vStr;
    FILE * pFile;
    if ( pFileName == NULL )
        sprintf( FileName, "%s_s%03d_g%03d_m%d.genlib", p->pName, (int)Slew, (int)Gain, nGatesMin );
    else
        sprintf( FileName, "%s", pFileName );
    pFile = fopen( FileName, "wb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open file \"%s\" for writing.\n", FileName );
        return;
    }
    vStr = Abc_SclProduceGenlibStr( p, Slew, Gain, nGatesMin, &nCellCount );
    fprintf( pFile, "%s", Vec_StrArray(vStr) );
    Vec_StrFree( vStr );
    fclose( pFile );
    printf( "Written GENLIB library with %d gates into file \"%s\".\n", nCellCount, FileName );
}

SC_WireLoad* Abc_SclFetchWireLoadModel	(	SC_Lib *	p,
		char *	pWLoadUsed
	)

Function*************************************************************

Synopsis [Returns the wireload model for the given area.]

Description []

SideEffects []

SeeAlso []

Definition at line 230 of file sclLibUtil.c.

{
    SC_WireLoad * pWL = NULL;
    int i;
    // Get the actual table and reformat it for 'wire_cap' output:
    assert( pWLoadUsed != NULL );
    SC_LibForEachWireLoad( p, pWL, i )
        if ( !strcmp(pWL->pName, pWLoadUsed) )
            break;
    if ( i == Vec_PtrSize(p->vWireLoads) )
    {
        Abc_Print( -1, "Cannot find wire load model \"%s\".\n", pWLoadUsed );
        exit(1);
    }
//    printf( "Using wireload model \"%s\".\n", pWL->pName );
    return pWL;
}

SC_Cell* Abc_SclFindInvertor	(	SC_Lib *	p,
		int	fFindBuff
	)

Function*************************************************************

Synopsis [Returns the largest inverter.]

Description []

SideEffects []

SeeAlso []

Definition at line 197 of file sclLibUtil.c.

{
    SC_Cell * pCell = NULL;
    word Truth = fFindBuff ? ABC_CONST(0xAAAAAAAAAAAAAAAA) : ABC_CONST(0x5555555555555555);
    int k;
    SC_LibForEachCellClass( p, pCell, k )
        if ( pCell->n_inputs == 1 && Vec_WrdEntry(SC_CellPin(pCell, 1)->vFunc, 0) == Truth )
            break;
    // take representative
    return pCell ? pCell->pRepr : NULL;
}

SC_Cell* Abc_SclFindSmallestGate	(	SC_Cell *	p,
		float	CinMin
	)

Definition at line 208 of file sclLibUtil.c.

{
    SC_Cell * pRes = NULL;
    int i;
    SC_RingForEachCell( p->pRepr, pRes, i )
        if ( SC_CellPinCapAve(pRes) > CinMin )
            return pRes;
    // take the largest gate
    return p->pRepr->pPrev;
}

SC_WireLoad* Abc_SclFindWireLoadModel	(	SC_Lib *	p,
		float	Area
	)

Definition at line 247 of file sclLibUtil.c.

{
    char * pWLoadUsed = NULL;
    int i;
    if ( p->default_wire_load_sel && strlen(p->default_wire_load_sel) )
    {
        SC_WireLoadSel * pWLS = NULL;
        SC_LibForEachWireLoadSel( p, pWLS, i )
            if ( !strcmp(pWLS->pName, p->default_wire_load_sel) )
                break;
        if ( i == Vec_PtrSize(p->vWireLoadSels) )
        {
            Abc_Print( -1, "Cannot find wire load selection model \"%s\".\n", p->default_wire_load_sel );
            exit(1);
        }
        for ( i = 0; i < Vec_FltSize(pWLS->vAreaFrom); i++)
            if ( Area >= Vec_FltEntry(pWLS->vAreaFrom, i) && Area <  Vec_FltEntry(pWLS->vAreaTo, i) )
            {
                pWLoadUsed = (char *)Vec_PtrEntry(pWLS->vWireLoadModel, i);
                break;
            }
        if ( i == Vec_FltSize(pWLS->vAreaFrom) )
            pWLoadUsed = (char *)Vec_PtrEntryLast(pWLS->vWireLoadModel);
    }
    else if ( p->default_wire_load && strlen(p->default_wire_load) )
        pWLoadUsed = p->default_wire_load;
    else
    {
//        Abc_Print( 0, "No wire model given.\n" );
        return NULL;
    }
    return Abc_SclFetchWireLoadModel( p, pWLoadUsed );
}

int Abc_SclHasDelayInfo

(

void *

pScl

)

Function*************************************************************

Synopsis [Returns 1 if the library has delay info.]

Description []

SideEffects []

SeeAlso []

Definition at line 292 of file sclLibUtil.c.

{
    SC_Lib * p = (SC_Lib *)pScl;
    SC_Cell * pCell;
    SC_Timing * pTime;
    pCell = Abc_SclFindInvertor(p, 0);
    if ( pCell == NULL )
        return 0;
    pTime = Scl_CellPinTime( pCell, 0 );
    if ( pTime == NULL )
        return 0;
    return 1;
}

void Abc_SclHashCells

(

SC_Lib *

p

)

Definition at line 65 of file sclLibUtil.c.

{
    SC_Cell * pCell;
    int i, * pPlace;
    assert( p->nBins == 0 );
    p->nBins = Abc_PrimeCudd( 5 * SC_LibCellNum(p) );
    p->pBins = ABC_FALLOC( int, p->nBins );
    SC_LibForEachCell( p, pCell, i )
    {
        pPlace = Abc_SclHashLookup( p, pCell->pName );
        assert( *pPlace == -1 );
        *pPlace = i;
    }
}

void Abc_SclInstallGenlib	(	void *	pScl,
		float	SlewInit,
		float	Gain,
		int	nGatesMin
	)

Function*************************************************************

Synopsis [Install library.]

Description []

SideEffects []

SeeAlso []

Definition at line 844 of file sclLibUtil.c.

{
    SC_Lib * p = (SC_Lib *)pScl;
    Vec_Str_t * vStr, * vStr2;
    float Slew = (SlewInit == 0) ? Abc_SclComputeAverageSlew(p) : SlewInit;
    int RetValue, nGateCount = SC_LibCellNum(p);
    if ( Gain == 0 )
        vStr = Abc_SclProduceGenlibStrSimple(p);
    else
        vStr = Abc_SclProduceGenlibStr( p, Slew, Gain, nGatesMin, &nGateCount );
    vStr2 = Vec_StrDup( vStr );
    RetValue = Mio_UpdateGenlib2( vStr, vStr2, p->pName, 0 );
    Vec_StrFree( vStr );
    Vec_StrFree( vStr2 );
    if ( !RetValue )
        printf( "Reading library has filed.\n" );
    else if ( Gain != 0 )
        printf( "Derived GENLIB library \"%s\" with %d gates using slew %.2f ps and gain %.2f.\n", p->pName, nGateCount, Slew, Gain );
//    else
//        printf( "Derived unit-delay GENLIB library \"%s\" with %d gates.\n", p->pName, nGateCount );
}

static SC_Lib* Abc_SclLibAlloc ( )

inlinestatic

Definition at line 343 of file sclLib.h.

{
    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;
}

int Abc_SclLibClassNum

(

SC_Lib *

pLib

)

Definition at line 93 of file sclLibUtil.c.

{
    SC_Cell * pRepr;
    int i, Count = 0;
    SC_LibForEachCellClass( pLib, pRepr, i )
        Count++;
    return Count;
}

static void Abc_SclLibFree ( SC_Lib *  p )

inlinestatic

Definition at line 443 of file sclLib.h.

{
    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 );
}

void Abc_SclLibNormalize

(

SC_Lib *

p

)

Definition at line 615 of file sclLibUtil.c.

{
    SC_WireLoad * pWL;
    SC_Cell * pCell;
    SC_Pin * pPin;
    SC_Timings * pTimings;
    SC_Timing * pTiming;
    int i, k, m, n;
    float Time = 1.0 * pow(10.0, 12 - p->unit_time);
    float Load = p->unit_cap_fst * pow(10.0, 15 - p->unit_cap_snd);
    if ( Time == 1 && Load == 1 )
        return;
    p->unit_time = 12;
    p->unit_cap_fst = 1;
    p->unit_cap_snd = 15;
    p->default_max_out_slew *= Time;
    SC_LibForEachWireLoad( p, pWL, i )
        pWL->cap *= Load;
    SC_LibForEachCell( p, pCell, i )
    SC_CellForEachPin( pCell, pPin, k )
    {
        pPin->cap *= Load;
        pPin->rise_cap *= Load;
        pPin->fall_cap *= Load;
        pPin->max_out_cap *= Load;
        pPin->max_out_slew *= Time;
        SC_PinForEachRTiming( pPin, pTimings, m )
        Vec_PtrForEachEntry( SC_Timing *, pTimings->vTimings, pTiming, n )
        {
            Abc_SclLibNormalizeSurface( pTiming->pCellRise, Time, Load );
            Abc_SclLibNormalizeSurface( pTiming->pCellFall, Time, Load );
            Abc_SclLibNormalizeSurface( pTiming->pRiseTrans, Time, Load );
            Abc_SclLibNormalizeSurface( pTiming->pFallTrans, Time, Load );
        }
    }
}

void Abc_SclLinkCells

(

SC_Lib *

p

)

Definition at line 129 of file sclLibUtil.c.

{
    Vec_Ptr_t * vList;
    SC_Cell * pCell, * pRepr = NULL;
    int i, k;
    assert( Vec_PtrSize(p->vCellClasses) == 0 );
    SC_LibForEachCell( p, pCell, i )
    {
        // find gate with the same function
        SC_LibForEachCellClass( p, pRepr, k )
            if ( pCell->n_inputs  == pRepr->n_inputs && 
                 pCell->n_outputs == pRepr->n_outputs && 
                 Vec_WrdEqual(SC_CellFunc(pCell), SC_CellFunc(pRepr)) )
                break;
        if ( k == Vec_PtrSize(p->vCellClasses) )
        {
            Vec_PtrPush( p->vCellClasses, pCell );
            pCell->pNext = pCell->pPrev = pCell;
            continue;
        }
        // add it to the list before the cell
        pRepr->pPrev->pNext = pCell; pCell->pNext = pRepr;
        pCell->pPrev = pRepr->pPrev; pRepr->pPrev = pCell;
    }
    // sort cells by size then by name
    qsort( (void *)Vec_PtrArray(p->vCellClasses), Vec_PtrSize(p->vCellClasses), sizeof(void *), (int(*)(const void *,const void *))Abc_SclCompareCells );
    // sort cell lists
    vList = Vec_PtrAlloc( 100 );
    SC_LibForEachCellClass( p, pRepr, k )
    {
        Vec_PtrClear( vList );
        SC_RingForEachCell( pRepr, pCell, i )
            Vec_PtrPush( vList, pCell );
        qsort( (void *)Vec_PtrArray(vList), Vec_PtrSize(vList), sizeof(void *), (int(*)(const void *,const void *))Abc_SclCompareCells );
        // create new representative
        pRepr = (SC_Cell *)Vec_PtrEntry( vList, 0 );
        pRepr->pNext = pRepr->pPrev = pRepr;
        pRepr->pRepr = pRepr;
        pRepr->pAve  = (SC_Cell *)Vec_PtrEntry( vList, Vec_PtrSize(vList)/2 );
        pRepr->Order = 0;
        pRepr->nGates = Vec_PtrSize(vList);
        // relink cells
        Vec_PtrForEachEntryStart( SC_Cell *, vList, pCell, i, 1 )
        {
            pRepr->pPrev->pNext = pCell; pCell->pNext = pRepr;
            pCell->pPrev = pRepr->pPrev; pRepr->pPrev = pCell;
            pCell->pRepr = pRepr;
            pCell->pAve  = (SC_Cell *)Vec_PtrEntry( vList, Vec_PtrSize(vList)/2 );
            pCell->Order = i;
            pCell->nGates = Vec_PtrSize(vList);
        }
        // update list
        Vec_PtrWriteEntry( p->vCellClasses, k, pRepr );
    }
    Vec_PtrFree( vList );
}

static SC_Pin* Abc_SclPinAlloc ( )

inlinestatic

Definition at line 327 of file sclLib.h.

{
    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 void Abc_SclPinFree ( SC_Pin *  p )

inlinestatic

Definition at line 421 of file sclLib.h.

{
    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 );
}

void Abc_SclPrintCells	(	SC_Lib *	p,
		float	Slew,
		float	Gain,
		int	fInvOnly,
		int	fShort
	)

Definition at line 503 of file sclLibUtil.c.

{
    SC_Cell * pCell, * pRepr;
    SC_Pin * pPin;
    int i, j, k, nLength = 0;
    float Slew = (SlewInit == 0) ? Abc_SclComputeAverageSlew(p) : SlewInit;
    float LD = 0, PD = 0;
    assert( Vec_PtrSize(p->vCellClasses) > 0 );
    printf( "Library \"%s\" ", p->pName );
    printf( "has %d cells in %d classes.  ", 
        Vec_PtrSize(p->vCells), Vec_PtrSize(p->vCellClasses) );
    if ( !fShort )
        printf( "Delay estimate is based on slew %.2f ps and gain %.2f.", Slew, Gain );
    printf( "\n" );
    Abc_SclMarkSkippedCells( p );
    // find the longest name
    SC_LibForEachCellClass( p, pRepr, k )
        SC_RingForEachCell( pRepr, pCell, i )
            nLength = Abc_MaxInt( nLength, strlen(pRepr->pName) );
    // print cells
    SC_LibForEachCellClass( p, pRepr, k )
    {
        if ( fInvOnly && pRepr->n_inputs != 1 )
            continue;
        SC_CellForEachPinOut( pRepr, pPin, i )
        {
            if ( i == pRepr->n_inputs )
            {
                printf( "Class%4d : ",   k );
                printf( "Cells =%3d   ", Abc_SclClassCellNum(pRepr) );
                printf( "Ins =%2d  ",    pRepr->n_inputs );
                printf( "Outs =%2d  ",   pRepr->n_outputs );
            }
            else
                printf( "                                            " );
            if ( pPin->func_text )
                printf( "%-30s", pPin->func_text  );
            printf( "    "  );
            Kit_DsdPrintFromTruth( (unsigned *)Vec_WrdArray(pPin->vFunc), pRepr->n_inputs );
            printf( "\n" );
            if ( fShort )
                continue;
            SC_RingForEachCell( pRepr, pCell, j )
            {
                printf( "  %3d ",           j+1 );
                printf( "%s",               pCell->fSkip ? "s" : " " );
                printf( " : " );
                printf( "%-*s  ",           nLength, pCell->pName );
                printf( "%2d   ",           pCell->drive_strength );
                printf( "A =%8.2f  ",       pCell->area );
                printf( "L =%8.2f  ",       pCell->leakage );
                if ( pCell->n_outputs == 1 )
                {
                    if ( Abc_SclComputeParametersCell( p, pCell, Slew, &LD, &PD ) )
                    {
                        printf( "D =%6.1f ps  ",    0.01 * Gain * LD + PD );
                        printf( "LD =%6.1f ps  ",   LD );
                        printf( "PD =%6.1f ps    ", PD );
                        printf( "C =%5.1f ff  ",    SC_CellPinCapAve(pCell) );
                        printf( "Cm =%5.0f ff    ", SC_CellPin(pCell, pCell->n_inputs)->max_out_cap );
                        printf( "Sm =%5.1f ps ",    SC_CellPin(pCell, pCell->n_inputs)->max_out_slew );
                    }
                }
                printf( "\n" );
            }
            break;
        }
    }
}

SC_Lib* Abc_SclReadFromFile

(

char *

pFileName

)

Definition at line 248 of file sclLibScl.c.

{
    SC_Lib * p;
    FILE * pFile;
    Vec_Str_t * vOut;
    int nFileSize;
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
        return NULL;
    }
    // get the file size, in bytes
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile );  
    rewind( pFile ); 
    // load the contents
    vOut = Vec_StrAlloc( nFileSize );
    vOut->nSize = vOut->nCap;
    assert( nFileSize == Vec_StrSize(vOut) );
    nFileSize = fread( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
    assert( nFileSize == Vec_StrSize(vOut) );
    fclose( pFile );
    // read the library
    p = Abc_SclReadFromStr( vOut );
    if ( p != NULL )
        p->pFileName = Abc_UtilStrsav( pFileName );
    if ( p != NULL )
        Abc_SclLibNormalize( p );
    Vec_StrFree( vOut );
    return p;
}

SC_Lib* Abc_SclReadFromStr

(

Vec_Str_t *

vOut

)

Definition at line 234 of file sclLibScl.c.

{
    SC_Lib * p;
    int Pos = 0;
    // read the library
    p = Abc_SclLibAlloc();
    if ( !Abc_SclReadLibrary( vOut, &Pos, p ) )
        return NULL;
    assert( Pos == Vec_StrSize(vOut) );
    // hash gates by name
    Abc_SclHashCells( p );
    Abc_SclLinkCells( p );
    return p;
}

SC_Lib* Abc_SclReadLiberty	(	char *	pFileName,
		int	fVerbose,
		int	fVeryVerbose
	)

Definition at line 1626 of file sclLiberty.c.

{
    SC_Lib * pLib;
    Scl_Tree_t * p;
    Vec_Str_t * vStr;
    p = Scl_LibertyParse( pFileName, fVeryVerbose );
    if ( p == NULL )
        return NULL;
//    Scl_LibertyParseDump( p, "temp_.lib" );
    // collect relevant data
    vStr = Scl_LibertyReadSclStr( p, fVerbose, fVeryVerbose );
    Scl_LibertyStop( p, fVeryVerbose );
    if ( vStr == NULL )
        return NULL;
    // construct SCL data-structure
    pLib = Abc_SclReadFromStr( vStr );
    if ( pLib == NULL )
        return NULL;
    pLib->pFileName = Abc_UtilStrsav( pFileName );
    Abc_SclLibNormalize( pLib );
    Vec_StrFree( vStr );
//    printf( "Average slew = %.2f ps\n", Abc_SclComputeAverageSlew(pLib) );
    return pLib;
}

static SC_Surface* Abc_SclSurfaceAlloc ( )

inlinestatic

Definition at line 301 of file sclLib.h.

{
    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 void Abc_SclSurfaceFree ( SC_Surface *  p )

inlinestatic

Definition at line 393 of file sclLib.h.

{
    Vec_FltFree( p->vIndex0 );
    Vec_FltFree( p->vIndex1 );
    Vec_VecFree( (Vec_Vec_t *)p->vData );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

static SC_TableTempl* Abc_SclTableTemplAlloc ( )

inlinestatic

Definition at line 293 of file sclLib.h.

{
    SC_TableTempl * p;
    p = ABC_CALLOC( SC_TableTempl, 1 );
    p->vVars  = Vec_PtrAlloc( 0 );
    p->vIndex = Vec_PtrAlloc( 0 );
    return p;
}

static void Abc_SclTableTemplFree ( SC_TableTempl *  p )

inlinestatic

Definition at line 386 of file sclLib.h.

{
    Vec_PtrFreeFree( p->vVars );
    Vec_VecFree( (Vec_Vec_t *)p->vIndex );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

static SC_Timing* Abc_SclTimingAlloc ( )

inlinestatic

Definition at line 310 of file sclLib.h.

{
    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 void Abc_SclTimingFree ( SC_Timing *  p )

inlinestatic

Definition at line 401 of file sclLib.h.

{
    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 SC_Timings* Abc_SclTimingsAlloc ( )

inlinestatic

Definition at line 320 of file sclLib.h.

{
    SC_Timings * p;
    p = ABC_CALLOC( SC_Timings, 1 );
    p->vTimings   = Vec_PtrAlloc( 0 );
    return p;
}

static void Abc_SclTimingsFree ( SC_Timings *  p )

inlinestatic

Definition at line 411 of file sclLib.h.

{
    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 SC_WireLoad* Abc_SclWireLoadAlloc ( )

inlinestatic

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Constructors of the library data-structures.]

Description []

SideEffects []

SeeAlso []

Definition at line 276 of file sclLib.h.

{
    SC_WireLoad * p;
    p = ABC_CALLOC( SC_WireLoad, 1 );
    p->vFanout = Vec_IntAlloc( 0 );
    p->vLen    = Vec_FltAlloc( 0 );
    return p;
}

static void Abc_SclWireLoadFree ( SC_WireLoad *  p )

inlinestatic

Function*************************************************************

Synopsis [Destructors of the library data-structures.]

Description []

SideEffects []

SeeAlso []

Definition at line 371 of file sclLib.h.

{
    Vec_IntFree( p->vFanout );
    Vec_FltFree( p->vLen );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

static SC_WireLoadSel* Abc_SclWireLoadSelAlloc ( )

inlinestatic

Definition at line 284 of file sclLib.h.

{
    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 void Abc_SclWireLoadSelFree ( SC_WireLoadSel *  p )

inlinestatic

Definition at line 378 of file sclLib.h.

{
    Vec_FltFree( p->vAreaFrom );
    Vec_FltFree( p->vAreaTo );
    Vec_PtrFreeFree( p->vWireLoadModel );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

void Abc_SclWriteLiberty	(	char *	pFileName,
		SC_Lib *	p
	)

Definition at line 660 of file sclLibScl.c.

{
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
        printf( "Cannot open text file \"%s\" for writing.\n", pFileName );
    else
    {
        Abc_SclWriteLibraryText( pFile, p );
        fclose( pFile );
        printf( "Dumped internal library into Liberty file \"%s\".\n", pFileName );
    }
}

void Abc_SclWriteScl	(	char *	pFileName,
		SC_Lib *	p
	)

Definition at line 444 of file sclLibScl.c.

{
    Vec_Str_t * vOut;
    vOut = Vec_StrAlloc( 10000 );
    Abc_SclWriteLibrary( vOut, p );
    if ( Vec_StrSize(vOut) > 0 )
    {
        FILE * pFile = fopen( pFileName, "wb" );
        if ( pFile == NULL )
            printf( "Cannot open file \"%s\" for writing.\n", pFileName );
        else
        {
            fwrite( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
            fclose( pFile );
        }
    }
    Vec_StrFree( vOut );    
}

static Vec_Wrd_t* SC_CellFunc ( SC_Cell *  p )

inlinestatic

Definition at line 242 of file sclLib.h.

{ return SC_CellPin(p, p->n_inputs)->vFunc;                       }

static SC_Pin* SC_CellPin ( SC_Cell *  p, int  i  )

inlinestatic

Definition at line 241 of file sclLib.h.

{ return (SC_Pin *)Vec_PtrEntry(p->vPins, i);                     }

static float SC_CellPinCap ( SC_Cell *  p, int  i  )

inlinestatic

Definition at line 243 of file sclLib.h.

{ return 0.5 * SC_CellPin(p, i)->rise_cap + 0.5 * SC_CellPin(p, i)->fall_cap; }

static float SC_CellPinCapAve ( SC_Cell *  p )

inlinestatic

Definition at line 244 of file sclLib.h.

{ 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 char* SC_CellPinName ( SC_Cell *  p, int  i  )

inlinestatic

Definition at line 246 of file sclLib.h.

{ return SC_CellPin(p, i)->pName;                                 }

static char* SC_CellPinOutFunc ( SC_Cell *  p, int  i  )

inlinestatic

Definition at line 245 of file sclLib.h.

{ return SC_CellPin(p, p->n_inputs + i)->func_text;               }

static SC_Cell* SC_LibCell ( SC_Lib *  p, int  i  )

inlinestatic

Definition at line 240 of file sclLib.h.

{ return (SC_Cell *)Vec_PtrEntry(p->vCells, i);                   }

static int SC_LibCellNum ( SC_Lib *  p )

inlinestatic

Definition at line 239 of file sclLib.h.

{ return Vec_PtrSize(p->vCells);                                  }

static void SC_PairAdd ( SC_Pair *  d, SC_Pair *  s  )

inlinestatic

Definition at line 235 of file sclLib.h.

{ d->rise += s->rise; d->fall += s->fall;}

static float SC_PairAve ( SC_Pair *  d )

inlinestatic

Definition at line 232 of file sclLib.h.

{ return 0.5 * d->rise + 0.5 * d->fall;  }

static void SC_PairClean ( SC_Pair *  d )

inlinestatic

GLOBAL VARIABLES ///.

MACRO DEFINITIONS ///

Definition at line 229 of file sclLib.h.

{ d->rise = d->fall = 0;                 }

static void SC_PairDup ( SC_Pair *  d, SC_Pair *  s  )

inlinestatic

Definition at line 233 of file sclLib.h.

{ *d = *s;                               }

static int SC_PairEqual ( SC_Pair *  d, SC_Pair *  s  )

inlinestatic

Definition at line 236 of file sclLib.h.

{ return d->rise == s->rise && d->fall == s->fall;                }

static int SC_PairEqualE ( SC_Pair *  d, SC_Pair *  s, float  E  )

inlinestatic

Definition at line 237 of file sclLib.h.

{ return d->rise - s->rise < E && s->rise - d->rise < E &&  d->fall - s->fall < E && s->fall - d->fall < E;    }

static float SC_PairMax ( SC_Pair *  d )

inlinestatic

Definition at line 230 of file sclLib.h.

{ return Abc_MaxFloat(d->rise, d->fall); }

static float SC_PairMin ( SC_Pair *  d )

inlinestatic

Definition at line 231 of file sclLib.h.

{ return Abc_MinFloat(d->rise, d->fall); }

static void SC_PairMove ( SC_Pair *  d, SC_Pair *  s  )

inlinestatic

Definition at line 234 of file sclLib.h.

{ *d = *s; s->rise = s->fall = 0;        }

static SC_Timing* Scl_CellPinTime ( SC_Cell *  pCell, int  iPin  )

inlinestatic

Function*************************************************************

Synopsis [Compute one timing edge.]

Description []

SideEffects []

SeeAlso []

Definition at line 565 of file sclLib.h.

{
    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 void Scl_LibHandleInputDriver ( SC_Cell *  pCell, SC_Pair *  pLoadIn, SC_Pair *  pArrOut, SC_Pair *  pSlewOut  )

inlinestatic

Definition at line 591 of file sclLib.h.

{
    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;
}

static float Scl_LibLookup ( SC_Surface *  p, float  slew, float  load  )

inlinestatic

Function*************************************************************

Synopsis [Lookup table delay computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 483 of file sclLib.h.

{
    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 void Scl_LibPinArrival ( SC_Timing *  pTime, SC_Pair *  pArrIn, SC_Pair *  pSlewIn, SC_Pair *  pLoad, SC_Pair *  pArrOut, SC_Pair *  pSlewOut  )

inlinestatic

Definition at line 523 of file sclLib.h.

{
    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 float Scl_LibPinArrivalEstimate ( SC_Cell *  pCell, int  iPin, float  Slew, float  Load  )

inlinestatic

Definition at line 578 of file sclLib.h.

{
    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 void Scl_LibPinDeparture ( SC_Timing *  pTime, SC_Pair *  pDepIn, SC_Pair *  pSlewIn, SC_Pair *  pLoad, SC_Pair *  pDepOut  )

inlinestatic

Definition at line 540 of file sclLib.h.

{
    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) );
    }
}