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

Include dependency graph for sclLib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SC_DontUse_

struct	SC_Pair_

struct	SC_PairI_

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 ///.

#define	SC_LibForEachCell(p, pCell, i)

#define	SC_LibForEachCellClass(p, pCell, i)

#define	SC_LibForEachWireLoad(p, pWL, i)

#define	SC_LibForEachWireLoadSel(p, pWLS, i)

#define	SC_LibForEachTempl(p, pTempl, i)

#define	SC_CellForEachPin(p, pPin, i)

#define	SC_CellForEachPinIn(p, pPin, i)

#define	SC_CellForEachPinOut(p, pPin, i)

#define	SC_RingForEachCell(pRing, pCell, i)

#define	SC_RingForEachCellRev(pRing, pCell, i)

#define	SC_PinForEachRTiming(p, pRTime, i)

Typedefs
typedef struct SC_DontUse_	SC_DontUse

typedef struct SC_Pair_	SC_Pair

typedef struct SC_PairI_	SC_PairI

typedef struct SC_SizePars_	SC_SizePars

typedef struct SC_BusPars_	SC_BusPars

typedef struct SC_WireLoad_	SC_WireLoad
	STRUCTURE DEFINITIONS ///.

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
SC_Lib *	Abc_SclReadLiberty (char *pFileName, int fVerbose, int fVeryVerbose, SC_DontUse dont_use, int fSkipMultiOuts)

SC_Lib *	Abc_SclReadFromGenlib (void *pLib)

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)

SC_Lib *	Abc_SclMergeLibraries (SC_Lib pLib1, SC_Lib pLib2, int fUsePrefix)

void	Abc_SclHashCells (SC_Lib *p)

int	Abc_SclCellFind (SC_Lib p, char pName)

int	Abc_SclClassCellNum (SC_Cell *pClass)

void	Abc_SclShortNames (SC_Lib *p)

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 fUseAll, int nGatesMin)

Macro Definition Documentation

◆ ABC_SCL_CUR_VERSION

#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.

◆ SC_CellForEachPin

#define SC_CellForEachPin	(	p,
		pPin,
		i )

Value:

Vec_PtrForEachEntry( SC_Pin *, &p->vPins, pPin, i )

p

Cube * p

Definition exorList.c:222

SC_Pin

struct SC_Pin_ SC_Pin

Definition sclLib.h:126

Vec_PtrForEachEntry

#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)

MACRO DEFINITIONS ///.

Definition vecPtr.h:55

Definition at line 274 of file sclLib.h.

◆ SC_CellForEachPinIn

#define SC_CellForEachPinIn	(	p,
		pPin,
		i )

Value:

Vec_PtrForEachEntryStop( SC_Pin *, &p->vPins, pPin, i, p->n_inputs )

Vec_PtrForEachEntryStop

#define Vec_PtrForEachEntryStop(Type, vVec, pEntry, i, Stop)

Definition vecPtr.h:59

Definition at line 275 of file sclLib.h.

◆ SC_CellForEachPinOut

#define SC_CellForEachPinOut	(	p,
		pPin,
		i )

Value:

Vec_PtrForEachEntryStart( SC_Pin *, &p->vPins, pPin, i, p->n_inputs )

Vec_PtrForEachEntryStart

#define Vec_PtrForEachEntryStart(Type, vVec, pEntry, i, Start)

Definition vecPtr.h:57

Definition at line 276 of file sclLib.h.

◆ SC_LibForEachCell

#define SC_LibForEachCell	(	p,
		pCell,
		i )

Value:

Vec_PtrForEachEntry( SC_Cell *, &p->vCells, pCell, i )

SC_Cell

struct SC_Cell_ SC_Cell

Definition sclLib.h:127

Definition at line 269 of file sclLib.h.

◆ SC_LibForEachCellClass

#define SC_LibForEachCellClass	(	p,
		pCell,
		i )

Value:

Vec_PtrForEachEntry( SC_Cell *, &p->vCellClasses, pCell, i )

Definition at line 270 of file sclLib.h.

◆ SC_LibForEachTempl

#define SC_LibForEachTempl	(	p,
		pTempl,
		i )

Value:

Vec_PtrForEachEntry( SC_TableTempl *, &p->vTempls, pTempl, i )

SC_TableTempl

struct SC_TableTempl_ SC_TableTempl

Definition sclLib.h:122

Definition at line 273 of file sclLib.h.

◆ SC_LibForEachWireLoad

#define SC_LibForEachWireLoad	(	p,
		pWL,
		i )

Value:

Vec_PtrForEachEntry( SC_WireLoad *, &p->vWireLoads, pWL, i )

SC_WireLoad

struct SC_WireLoad_ SC_WireLoad

STRUCTURE DEFINITIONS ///.

Definition sclLib.h:120

Definition at line 271 of file sclLib.h.

◆ SC_LibForEachWireLoadSel

#define SC_LibForEachWireLoadSel	(	p,
		pWLS,
		i )

Value:

Vec_PtrForEachEntry( SC_WireLoadSel *, &p->vWireLoadSels, pWLS, i )

SC_WireLoadSel

struct SC_WireLoadSel_ SC_WireLoadSel

Definition sclLib.h:121

Definition at line 272 of file sclLib.h.

◆ SC_PinForEachRTiming

#define SC_PinForEachRTiming	(	p,
		pRTime,
		i )

Value:

Vec_PtrForEachEntry( SC_Timings *, &p->vRTimings, pRTime, i )

SC_Timings

struct SC_Timings_ SC_Timings

Definition sclLib.h:125

Definition at line 279 of file sclLib.h.

◆ SC_RingForEachCell

#define SC_RingForEachCell	(	pRing,
		pCell,
		i )

Value:

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

Definition at line 277 of file sclLib.h.

◆ SC_RingForEachCellRev

#define SC_RingForEachCellRev	(	pRing,
		pCell,
		i )

Value:

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

Definition at line 278 of file sclLib.h.

Typedef Documentation

◆ SC_BusPars

typedef struct SC_BusPars_ SC_BusPars

Definition at line 102 of file sclLib.h.

◆ SC_Cell

typedef struct SC_Cell_ SC_Cell

Definition at line 127 of file sclLib.h.

◆ SC_DontUse

typedef struct SC_DontUse_ SC_DontUse

Definition at line 62 of file sclLib.h.

◆ SC_Lib

typedef struct SC_Lib_ SC_Lib

Definition at line 128 of file sclLib.h.

◆ SC_Pair

typedef struct SC_Pair_ SC_Pair

Definition at line 69 of file sclLib.h.

◆ SC_PairI

typedef struct SC_PairI_ SC_PairI

Definition at line 75 of file sclLib.h.

◆ SC_Pin

typedef struct SC_Pin_ SC_Pin

Definition at line 126 of file sclLib.h.

◆ SC_SizePars

typedef struct SC_SizePars_ SC_SizePars

Definition at line 82 of file sclLib.h.

◆ SC_Surface

typedef struct SC_Surface_ SC_Surface

Definition at line 123 of file sclLib.h.

◆ SC_TableTempl

typedef struct SC_TableTempl_ SC_TableTempl

Definition at line 122 of file sclLib.h.

◆ SC_Timing

typedef struct SC_Timing_ SC_Timing

Definition at line 124 of file sclLib.h.

◆ SC_Timings

typedef struct SC_Timings_ SC_Timings

Definition at line 125 of file sclLib.h.

◆ SC_WireLoad

typedef struct SC_WireLoad_ SC_WireLoad

STRUCTURE DEFINITIONS ///.

Definition at line 120 of file sclLib.h.

◆ SC_WireLoadSel

typedef struct SC_WireLoadSel_ SC_WireLoadSel

Definition at line 121 of file sclLib.h.

Enumeration Type Documentation

◆ SC_Dir

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;

◆ SC_TSense

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

◆ Abc_SclCellFind()

int Abc_SclCellFind	(	SC_Lib *	p,
		char *	pName )

extern

Definition at line 81 of file sclLibUtil.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclClassCellNum()

int Abc_SclClassCellNum ( SC_Cell * pClass )

extern

Definition at line 86 of file sclLibUtil.c.

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

Here is the caller graph for this function:

◆ Abc_SclComputeAverageSlew()

float Abc_SclComputeAverageSlew ( SC_Lib * p )

extern

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

Synopsis [Returns "average" slew.]

Description []

SideEffects []

SeeAlso []

Definition at line 452 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 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclConvertLeakageIntoArea()

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

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 719 of file sclLibUtil.c.

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

◆ Abc_SclDumpGenlib()

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

extern

Definition at line 1055 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, 0, &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 );
}

Here is the call graph for this function:

◆ Abc_SclFetchWireLoadModel()

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

extern

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 365 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclFindInvertor()

SC_Cell * Abc_SclFindInvertor	(	SC_Lib *	p,
		int	fFindBuff )

extern

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

Synopsis [Returns the largest inverter.]

Description []

SideEffects []

SeeAlso []

Definition at line 332 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;
}

Here is the caller graph for this function:

◆ Abc_SclFindSmallestGate()

SC_Cell * Abc_SclFindSmallestGate	(	SC_Cell *	p,
		float	CinMin )

extern

Definition at line 343 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;
}

Here is the caller graph for this function:

◆ Abc_SclFindWireLoadModel()

SC_WireLoad * Abc_SclFindWireLoadModel	(	SC_Lib *	p,
		float	Area )

extern

Definition at line 382 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 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclHasDelayInfo()

int Abc_SclHasDelayInfo ( void * pScl )

extern

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 427 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclHashCells()

void Abc_SclHashCells ( SC_Lib * p )

extern

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 );
        if ( *pPlace != -1 && pCell->pName )
            printf( "There are two standard cells with the same name (%s).\n", pCell->pName );
        assert( *pPlace == -1 );
        *pPlace = i;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclInstallGenlib()

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

extern

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

Synopsis [Install library.]

Description []

SideEffects []

SeeAlso []

Definition at line 1109 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, fUseAll, &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 );
}

Here is the call graph for this function:

◆ Abc_SclLibClassNum()

int Abc_SclLibClassNum ( SC_Lib * pLib )

extern

Definition at line 95 of file sclLibUtil.c.

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

Here is the caller graph for this function:

◆ Abc_SclLibNormalize()

void Abc_SclLibNormalize ( SC_Lib * p )

extern

Definition at line 750 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 );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclLinkCells()

void Abc_SclLinkCells ( SC_Lib * p )

extern

Definition at line 264 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), (size_t)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 );
}

Here is the caller graph for this function:

◆ Abc_SclMergeLibraries()

SC_Lib * Abc_SclMergeLibraries	(	SC_Lib *	pLib1,
		SC_Lib *	pLib2,
		int	fUsePrefix )

extern

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

Synopsis [Appends cells of pLib2 to those of pLib1.]

Description []

SideEffects []

SeeAlso []

Definition at line 869 of file sclLibScl.c.

{
    Vec_Str_t * vOut = Vec_StrAlloc( 10000 );
    int n_valid_cells2 = Abc_SclCountValidCells( pLib2 );
    Abc_SclWriteLibrary( vOut, pLib1, n_valid_cells2, fUsePrefix );
    Abc_SclWriteLibraryCellsOnly( vOut, pLib2, fUsePrefix ? 2 : 0 );
    SC_Lib * p = Abc_SclReadFromStr( vOut );
    p->pFileName = Abc_UtilStrsav( pLib1->pFileName );
    p->pName = ABC_ALLOC( char, strlen(pLib1->pName) + strlen(pLib2->pName) + 10 );
    sprintf( p->pName, "%s__and__%s", pLib1->pName, pLib2->pName );
    Vec_StrFree( vOut );
    printf( "Updated library \"%s\" with additional %d cells from library \"%s\".\n", pLib1->pName, n_valid_cells2, pLib2->pName );
    return p;
}

Here is the call graph for this function:

◆ Abc_SclPrintCells()

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

extern

Definition at line 638 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;
        }
    }
}

Here is the call graph for this function:

◆ Abc_SclReadFromFile()

SC_Lib * Abc_SclReadFromFile ( char * pFileName )

extern

Definition at line 417 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;
}

Here is the call graph for this function:

◆ Abc_SclReadFromGenlib()

SC_Lib * Abc_SclReadFromGenlib ( void * pLib )

extern

Definition at line 169 of file sclLibScl.c.

{
    Mio_Library_t * pLib = (Mio_Library_t *)pLib0;
    SC_Lib * p = Abc_SclLibAlloc();
    if ( !Abc_SclReadLibraryGenlib( p, pLib ) )
        return NULL;
    // hash gates by name
    Abc_SclHashCells( p );
    Abc_SclLinkCells( p );
    return p;
}

Here is the call graph for this function:

◆ Abc_SclReadFromStr()

SC_Lib * Abc_SclReadFromStr ( Vec_Str_t * vOut )

extern

Definition at line 403 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclReadLiberty()

SC_Lib * Abc_SclReadLiberty	(	char *	pFileName,
		int	fVerbose,
		int	fVeryVerbose,
		SC_DontUse	dont_use,
		int	fSkipMultiOuts )

extern

Definition at line 1768 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, dont_use, fSkipMultiOuts );
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SclShortNames()

void Abc_SclShortNames ( SC_Lib * p )

extern

Definition at line 195 of file sclLibUtil.c.

{
    char Buffer[10000];
    SC_Cell * pClass, * pCell; SC_Pin * pPin;
    int i, k, n, nClasses = Abc_SclLibClassNum(p);
    unsigned char nDigits = (unsigned char)Abc_Base10Log( nClasses );
    // itereate through classes
    SC_LibForEachCellClass( p, pClass, i )
    {
        unsigned char nDigits2 = (unsigned char)Abc_Base10Log( Abc_SclClassCellNum(pClass) );
        SC_RingForEachCell( pClass, pCell, k )
        {
            ABC_FREE( pCell->pName );
            sprintf( Buffer, "g%0*d_%0*d", nDigits, i, nDigits2, k );
            pCell->pName = Abc_UtilStrsav( Buffer );
            // formula
            SC_CellForEachPinOut( pCell, pPin, n )
                Abc_SclPinUpdate( pCell, pPin, Buffer );
            // pin names
            SC_CellForEachPinIn( pCell, pPin, n )
            {
                ABC_FREE( pPin->pName );
                sprintf( Buffer, "%c", (char)('a'+n) );
                pPin->pName = Abc_UtilStrsav( Buffer );
            }
            SC_CellForEachPinOut( pCell, pPin, n )
            {
                ABC_FREE( pPin->pName );
                sprintf( Buffer, "%c", (char)('z'-n+pCell->n_inputs) );
                pPin->pName = Abc_UtilStrsav( Buffer );
            }
        }
    }
    p->nBins = 0;
    ABC_FREE( p->pBins );
    Abc_SclHashCells( p );
    // update library name
    printf( "Renaming library \"%s\" into \"%s%d\".\n", p->pName, "lib", SC_LibCellNum(p) );
    ABC_FREE( p->pName );
    sprintf( Buffer, "lib%d", SC_LibCellNum(p) );
    p->pName = Abc_UtilStrsav( Buffer );
}

Here is the call graph for this function:

◆ Abc_SclWriteLiberty()

void Abc_SclWriteLiberty	(	char *	pFileName,
		SC_Lib *	p )

extern

Definition at line 845 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 with %d cells into Liberty file \"%s\".\n", SC_LibCellNum(p), pFileName );
    }
}

◆ Abc_SclWriteScl()

void Abc_SclWriteScl	(	char *	pFileName,
		SC_Lib *	p )

extern

Definition at line 629 of file sclLibScl.c.

{
    Vec_Str_t * vOut;
    vOut = Vec_StrAlloc( 10000 );
    Abc_SclWriteLibrary( vOut, p, 0, 0 );
    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 );    
}

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ ABC_SCL_CUR_VERSION

◆ SC_CellForEachPin

◆ SC_CellForEachPinIn

◆ SC_CellForEachPinOut

◆ SC_LibForEachCell

◆ SC_LibForEachCellClass

◆ SC_LibForEachTempl

◆ SC_LibForEachWireLoad

◆ SC_LibForEachWireLoadSel

◆ SC_PinForEachRTiming

◆ SC_RingForEachCell

◆ SC_RingForEachCellRev

Typedef Documentation

◆ SC_BusPars

◆ SC_Cell

◆ SC_DontUse

◆ SC_Lib

◆ SC_Pair

◆ SC_PairI

◆ SC_Pin

◆ SC_SizePars

◆ SC_Surface

◆ SC_TableTempl

◆ SC_Timing

◆ SC_Timings

◆ SC_WireLoad

◆ SC_WireLoadSel

Enumeration Type Documentation

◆ SC_Dir

◆ SC_TSense

Function Documentation

◆ Abc_SclCellFind()

◆ Abc_SclClassCellNum()

◆ Abc_SclComputeAverageSlew()

◆ Abc_SclConvertLeakageIntoArea()

◆ Abc_SclDumpGenlib()

◆ Abc_SclFetchWireLoadModel()

◆ Abc_SclFindInvertor()

◆ Abc_SclFindSmallestGate()

◆ Abc_SclFindWireLoadModel()

◆ Abc_SclHasDelayInfo()

◆ Abc_SclHashCells()

◆ Abc_SclInstallGenlib()

◆ Abc_SclLibClassNum()

◆ Abc_SclLibNormalize()

◆ Abc_SclLinkCells()

◆ Abc_SclMergeLibraries()

◆ Abc_SclPrintCells()

◆ Abc_SclReadFromFile()

◆ Abc_SclReadFromGenlib()

◆ Abc_SclReadFromStr()

◆ Abc_SclReadLiberty()

◆ Abc_SclShortNames()

◆ Abc_SclWriteLiberty()

◆ Abc_SclWriteScl()