ruby_abc 0.0.3 → 0.1.0

data/ext/abc/src/map/scl/sclLibUtil.c

@@ -1,1078 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [sclLibUtil.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Standard-cell library representation.]
-
-  Synopsis    [Various library utilities.]
-
-  Author      [Alan Mishchenko, Niklas Een]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - August 24, 2012.]
-
-  Revision    [$Id: sclLibUtil.c,v 1.0 2012/08/24 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "sclLib.h"
-#include "misc/st/st.h"
-#include "map/mio/mio.h"
-#include "bool/kit/kit.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Reading library from file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static unsigned Abc_SclHashString( char * pName, int TableSize ) 
-{
-    static int s_Primes[10] = { 1291, 1699, 2357, 4177, 5147, 5647, 6343, 7103, 7873, 8147 };
-    unsigned i, Key = 0;
-    for ( i = 0; pName[i] != '\0'; i++ )
-        Key += s_Primes[i%10]*pName[i]*pName[i];
-    return Key % TableSize;
-}
-int * Abc_SclHashLookup( SC_Lib * p, char * pName )
-{
-    int i;
-    for ( i = Abc_SclHashString(pName, p->nBins); i < p->nBins; i = (i + 1) % p->nBins )
-        if ( p->pBins[i] == -1 || !strcmp(pName, SC_LibCell(p, p->pBins[i])->pName) )
-            return p->pBins + i;
-    assert( 0 );
-    return NULL;
-}
-void Abc_SclHashCells( SC_Lib * p )
-{
-    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;
-    }
-}
-int Abc_SclCellFind( SC_Lib * p, char * pName )
-{
-    int *pPlace = Abc_SclHashLookup( p, pName );
-    return pPlace ? *pPlace : -1;
-}
-int Abc_SclClassCellNum( SC_Cell * pClass )
-{
-    SC_Cell * pCell;
-    int i, Count = 0;
-    SC_RingForEachCell( pClass, pCell, i )
-        if ( !pCell->fSkip )
-            Count++;
-    return Count;
-}
-int Abc_SclLibClassNum( SC_Lib * pLib )
-{
-    SC_Cell * pRepr;
-    int i, Count = 0;
-    SC_LibForEachCellClass( pLib, pRepr, i )
-        Count++;
-    return Count;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Change cell names and pin names.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Abc_SclIsChar( char c )
-{
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
-}
-static inline int Abc_SclIsName( char c )
-{
-    return Abc_SclIsChar(c) || (c >= '0' && c <= '9');
-}
-static inline char * Abc_SclFindLimit( char * pName )
-{
-    assert( Abc_SclIsChar(*pName) );
-    while ( Abc_SclIsName(*pName) )
-        pName++;
-    return pName;
-}
-static inline int Abc_SclAreEqual( char * pBase, char * pName, char * pLimit )
-{
-    return !strncmp( pBase, pName, pLimit - pName );
-}
-void Abc_SclShortFormula( SC_Cell * pCell, char * pForm, char * pBuffer )
-{
-    SC_Pin * pPin; int i;
-    char * pTemp, * pLimit;
-    for ( pTemp = pForm; *pTemp; )
-    {
-        if ( !Abc_SclIsChar(*pTemp) )
-        {
-            *pBuffer++ = *pTemp++;
-            continue;
-        }
-        pLimit = Abc_SclFindLimit( pTemp );
-        SC_CellForEachPinIn( pCell, pPin, i )
-            if ( Abc_SclAreEqual( pPin->pName, pTemp, pLimit ) )
-            {
-                *pBuffer++ = 'a' + i;
-                break;
-            }
-        assert( i < pCell->n_inputs );
-        pTemp = pLimit;
-    }
-    *pBuffer++ = 0;
-}
-static inline void Abc_SclTimingUpdate( SC_Cell * pCell, SC_Timing * p, char * Buffer )
-{
-    SC_Pin * pPin; int i;
-    SC_CellForEachPinIn( pCell, pPin, i )
-        if ( p->related_pin && !strcmp(p->related_pin, pPin->pName) )
-        {
-            ABC_FREE( p->related_pin );
-            sprintf( Buffer, "%c", 'a'+i );
-            p->related_pin = Abc_UtilStrsav( Buffer );
-        }
-}
-static inline void Abc_SclTimingsUpdate( SC_Cell * pCell, SC_Timings * p, char * Buffer )
-{
-    SC_Timing * pTemp; int i;
-    Vec_PtrForEachEntry( SC_Timing *, &p->vTimings, pTemp, i )
-        Abc_SclTimingUpdate( pCell, pTemp, Buffer );
-}
-static inline void Abc_SclPinUpdate( SC_Cell * pCell, SC_Pin * p, char * Buffer )
-{
-    // update pin names in the timing
-    SC_Timings * pTemp; int i;
-    SC_PinForEachRTiming( p, pTemp, i )
-    {
-        SC_Pin * pPin; int k;
-        Abc_SclTimingsUpdate( pCell, pTemp, Buffer );
-        SC_CellForEachPinIn( pCell, pPin, k )
-            if ( pTemp->pName && !strcmp(pTemp->pName, pPin->pName) )
-            {
-                ABC_FREE( pTemp->pName );
-                sprintf( Buffer, "%c", 'a'+k );
-                pTemp->pName = Abc_UtilStrsav( Buffer );
-            }
-    }
-    // update formula
-    Abc_SclShortFormula( pCell, p->func_text, Buffer );
-    ABC_FREE( p->func_text );
-    p->func_text = Abc_UtilStrsav( Buffer );
-}
-void Abc_SclShortNames( SC_Lib * p )
-{
-    char Buffer[10000];
-    SC_Cell * pClass, * pCell; SC_Pin * pPin;
-    int i, k, n, nClasses = Abc_SclLibClassNum(p);
-    int nDigits = Abc_Base10Log( nClasses );
-    // itereate through classes
-    SC_LibForEachCellClass( p, pClass, i )
-    {
-        int nDigits2 = 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", 'a'+n );
-                pPin->pName = Abc_UtilStrsav( Buffer );
-            }
-            SC_CellForEachPinOut( pCell, pPin, n )
-            {
-                ABC_FREE( pPin->pName );
-                sprintf( Buffer, "%c", '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 );
-}
-/**Function*************************************************************
-
-  Synopsis    [Links equal gates into rings while sorting them by area.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Abc_SclCompareCells( SC_Cell ** pp1, SC_Cell ** pp2 )
-{
-    if ( (*pp1)->n_inputs < (*pp2)->n_inputs )
-        return -1;
-    if ( (*pp1)->n_inputs > (*pp2)->n_inputs )
-        return 1;
-//    if ( (*pp1)->area < (*pp2)->area )
-//        return -1;
-//    if ( (*pp1)->area > (*pp2)->area )
-//        return 1;
-    if ( SC_CellPinCapAve(*pp1) < SC_CellPinCapAve(*pp2) )
-        return -1;
-    if ( SC_CellPinCapAve(*pp1) > SC_CellPinCapAve(*pp2) )
-        return 1;
-    return strcmp( (*pp1)->pName, (*pp2)->pName );
-}
-void Abc_SclLinkCells( SC_Lib * p )
-{
-    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 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the largest inverter.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-SC_Cell * Abc_SclFindInvertor( SC_Lib * p, int fFindBuff )
-{
-    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 )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the wireload model for the given area.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-SC_WireLoad * Abc_SclFetchWireLoadModel( SC_Lib * p, char * pWLoadUsed )
-{
-    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_WireLoad * Abc_SclFindWireLoadModel( SC_Lib * p, float Area )
-{
-    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 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if the library has delay info.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_SclHasDelayInfo( void * pScl )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns "average" slew.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-float Abc_SclComputeAverageSlew( SC_Lib * p )
-{
-    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 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute delay parameters of pin/cell/class.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_SclComputeParametersPin( SC_Lib * p, SC_Cell * pCell, int iPin, float Slew, float * pLD, float * pPD )
-{
-    SC_Pair Load0, Load1, Load2;
-    SC_Pair ArrIn  = { 0.0, 0.0 };
-    SC_Pair SlewIn = { Slew, Slew };
-    SC_Pair ArrOut0 = { 0.0, 0.0 };
-    SC_Pair ArrOut1 = { 0.0, 0.0 };
-    SC_Pair ArrOut2 = { 0.0, 0.0 };
-    SC_Pair SlewOut = { 0.0, 0.0 };
-    SC_Timing * pTime = Scl_CellPinTime( pCell, iPin );
-    Vec_Flt_t * vIndex = pTime ? &pTime->pCellRise.vIndex1 : NULL; // capacitance
-    if ( vIndex == NULL )
-        return 0;
-    // handle constant table
-    if ( Vec_FltSize(vIndex) == 1 )
-    {
-        *pLD = 0;
-        *pPD = Vec_FltEntry( (Vec_Flt_t *)Vec_PtrEntry(&pTime->pCellRise.vData, 0), 0 );
-        return 1;
-    }
-    // get load points
-    Load0.rise = Load0.fall = 0.0;
-    Load1.rise = Load1.fall = Vec_FltEntry( vIndex, 0 );
-    Load2.rise = Load2.fall = Vec_FltEntry( vIndex, Vec_FltSize(vIndex) - 2 );
-    // compute delay
-    Scl_LibPinArrival( pTime, &ArrIn, &SlewIn, &Load0, &ArrOut0, &SlewOut );
-    Scl_LibPinArrival( pTime, &ArrIn, &SlewIn, &Load1, &ArrOut1, &SlewOut );
-    Scl_LibPinArrival( pTime, &ArrIn, &SlewIn, &Load2, &ArrOut2, &SlewOut );
-    ArrOut0.rise = 0.5 * ArrOut0.rise + 0.5 * ArrOut0.fall;
-    ArrOut1.rise = 0.5 * ArrOut1.rise + 0.5 * ArrOut1.fall;
-    ArrOut2.rise = 0.5 * ArrOut2.rise + 0.5 * ArrOut2.fall;
-    // get tangent
-    *pLD = (ArrOut2.rise - ArrOut1.rise) / ((Load2.rise - Load1.rise) / SC_CellPinCap(pCell, iPin));
-    // get constant
-    *pPD = ArrOut0.rise;
-    return 1;
-}
-int Abc_SclComputeParametersCell( SC_Lib * p, SC_Cell * pCell, float Slew, float * pLD, float * pPD )
-{
-    SC_Pin * pPin;
-    float LD, PD, ld, pd;
-    int i;
-    LD = PD = ld = pd = 0;
-    SC_CellForEachPinIn( pCell, pPin, i )
-    {
-        if ( !Abc_SclComputeParametersPin( p, pCell, i, Slew, &ld, &pd ) )
-            return 0;
-        LD += ld; PD += pd;
-    }
-    *pLD = LD / Abc_MaxInt(1, pCell->n_inputs);
-    *pPD = PD / Abc_MaxInt(1, pCell->n_inputs);
-    return 1;
-}
-void Abc_SclComputeParametersClass( SC_Lib * p, SC_Cell * pRepr, float Slew, float * pLD, float * pPD )
-{
-    SC_Cell * pCell;
-    float LD, PD, ld, pd;
-    int i, Count = 0;
-    LD = PD = ld = pd = 0;
-    SC_RingForEachCell( pRepr, pCell, i )
-    {
-        Abc_SclComputeParametersCell( p, pCell, Slew, &ld, &pd );
-        LD += ld; PD += pd;
-        Count++;
-    }
-    *pLD = LD / Abc_MaxInt(1, Count);
-    *pPD = PD / Abc_MaxInt(1, Count);
-}
-void Abc_SclComputeParametersClassPin( SC_Lib * p, SC_Cell * pRepr, int iPin, float Slew, float * pLD, float * pPD )
-{
-    SC_Cell * pCell;
-    float LD, PD, ld, pd;
-    int i, Count = 0;
-    LD = PD = ld = pd = 0;
-    SC_RingForEachCell( pRepr, pCell, i )
-    {
-        Abc_SclComputeParametersPin( p, pCell, iPin, Slew, &ld, &pd );
-        LD += ld; PD += pd;
-        Count++;
-    }
-    *pLD = LD / Abc_MaxInt(1, Count);
-    *pPD = PD / Abc_MaxInt(1, Count);
-}
-float Abc_SclComputeDelayCellPin( SC_Lib * p, SC_Cell * pCell, int iPin, float Slew, float Gain )
-{
-    float LD = 0, PD = 0;
-    Abc_SclComputeParametersPin( p, pCell, iPin, Slew, &LD, &PD );
-    return 0.01 * LD * Gain + PD;
-}
-float Abc_SclComputeDelayClassPin( SC_Lib * p, SC_Cell * pRepr, int iPin, float Slew, float Gain )
-{
-    SC_Cell * pCell;
-    float Delay = 0;
-    int i, Count = 0;
-    SC_RingForEachCell( pRepr, pCell, i )
-    {
-        if ( pCell->fSkip ) 
-            continue;
-//        if ( pRepr == pCell ) // skip the first gate
-//            continue;
-        Delay += Abc_SclComputeDelayCellPin( p, pCell, iPin, Slew, Gain );
-        Count++;
-    }
-    return Delay / Abc_MaxInt(1, Count);
-}
-float Abc_SclComputeAreaClass( SC_Cell * pRepr )
-{
-    SC_Cell * pCell;
-    float Area = 0;
-    int i, Count = 0;
-    SC_RingForEachCell( pRepr, pCell, i )
-    {
-        if ( pCell->fSkip ) 
-            continue;
-        Area += pCell->area;
-        Count++;
-    }
-    return Area / Abc_MaxInt(1, Count);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Print cells]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_SclMarkSkippedCells( SC_Lib * p )
-{
-    char FileName[1000];
-    char Buffer[1000], * pName;
-    SC_Cell * pCell;
-    FILE * pFile;
-    int CellId, nSkipped = 0;
-    sprintf( FileName, "%s.skip", p->pName );
-    pFile = fopen( FileName, "rb" );
-    if ( pFile == NULL )
-        return;
-    while ( fgets( Buffer, 999, pFile ) != NULL )
-    {
-        pName = strtok( Buffer, "\r\n\t " );
-        if ( pName == NULL )
-            continue;
-        CellId = Abc_SclCellFind( p, pName );
-        if ( CellId == -1 )
-        {
-            printf( "Cannot find cell \"%s\" in the library \"%s\".\n", pName, p->pName );
-            continue;
-        }
-        pCell = SC_LibCell( p, CellId );
-        pCell->fSkip = 1;
-        nSkipped++;
-    }
-    fclose( pFile );
-    printf( "Marked %d cells for skipping in the library \"%s\".\n", nSkipped, p->pName );
-}
-void Abc_SclPrintCells( SC_Lib * p, float SlewInit, float Gain, int fInvOnly, int fShort )
-{
-    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;
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_SclConvertLeakageIntoArea( SC_Lib * p, float A, float B )
-{
-    SC_Cell * pCell; int i;
-    SC_LibForEachCell( p, pCell, i )
-        pCell->area = A * pCell->area + B * pCell->leakage;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Print cells]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_SclLibNormalizeSurface( SC_Surface * p, float Time, float Load )
-{
-    Vec_Flt_t * vArray;
-    int i, k; float Entry;
-    Vec_FltForEachEntry( &p->vIndex0, Entry, i ) // slew
-        Vec_FltWriteEntry( &p->vIndex0, i, Time * Entry );
-    Vec_FltForEachEntry( &p->vIndex1, Entry, i ) // load
-        Vec_FltWriteEntry( &p->vIndex1, i, Load * Entry );
-    Vec_PtrForEachEntry( Vec_Flt_t *, &p->vData, vArray, k )
-        Vec_FltForEachEntry( vArray, Entry, i ) // delay/slew
-            Vec_FltWriteEntry( vArray, i, Time * Entry );
-}
-void Abc_SclLibNormalize( SC_Lib * p )
-{
-    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 );
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives simple GENLIB library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Str_t * Abc_SclProduceGenlibStrSimple( SC_Lib * p )
-{
-    char Buffer[200];
-    Vec_Str_t * vStr;
-    SC_Cell * pCell;
-    SC_Pin * pPin, * pPinOut;
-    int i, j, k, Count = 2;
-    // mark skipped cells
-//    Abc_SclMarkSkippedCells( p );
-    vStr = Vec_StrAlloc( 1000 );
-    Vec_StrPrintStr( vStr, "GATE _const0_            0.00 z=CONST0;\n" );
-    Vec_StrPrintStr( vStr, "GATE _const1_            0.00 z=CONST1;\n" );
-    SC_LibForEachCell( p, pCell, i )
-    {
-        if ( pCell->n_inputs == 0 )
-            continue;
-        assert( strlen(pCell->pName) < 200 );
-        SC_CellForEachPinOut( pCell, pPinOut, j )
-        {
-            Vec_StrPrintStr( vStr, "GATE " );
-            sprintf( Buffer, "%-16s", pCell->pName );
-            Vec_StrPrintStr( vStr, Buffer );
-            Vec_StrPrintStr( vStr, " " );
-            sprintf( Buffer, "%7.2f", pCell->area );
-            Vec_StrPrintStr( vStr, Buffer );
-            Vec_StrPrintStr( vStr, " " );
-            Vec_StrPrintStr( vStr, pPinOut->pName );
-            Vec_StrPrintStr( vStr, "=" );
-            Vec_StrPrintStr( vStr, pPinOut->func_text ? pPinOut->func_text : "?" );
-            Vec_StrPrintStr( vStr, ";\n" );
-            SC_CellForEachPinIn( pCell, pPin, k )
-            {
-                Vec_StrPrintStr( vStr, "         PIN " );
-                sprintf( Buffer, "%-4s", pPin->pName );
-                Vec_StrPrintStr( vStr, Buffer );
-                sprintf( Buffer, " UNKNOWN  1  999  1.00  0.00  1.00  0.00\n" );
-                Vec_StrPrintStr( vStr, Buffer );
-            }
-            Count++;
-        }
-    }
-    Vec_StrPrintStr( vStr, "\n.end\n" );
-    Vec_StrPush( vStr, '\0' );
-//    printf( "GENLIB library with %d gates is produced:\n", Count );
-//    printf( "%s", Vec_StrArray(vStr) );
-    return vStr;
-}
-Mio_Library_t * Abc_SclDeriveGenlibSimple( void * pScl )
-{
-    SC_Lib * p = (SC_Lib *)pScl;
-    Vec_Str_t * vStr = Abc_SclProduceGenlibStrSimple( p );
-    Mio_Library_t * pLib = Mio_LibraryRead( p->pFileName, Vec_StrArray(vStr), NULL, 0 );  
-    Vec_StrFree( vStr );
-    if ( pLib )
-        printf( "Derived GENLIB library \"%s\" with %d gates.\n", p->pName, SC_LibCellNum(p) );
-    else
-        printf( "Reading library has filed.\n" );
-    return pLib;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Derive GENLIB library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Str_t * Abc_SclProduceGenlibStr( SC_Lib * p, float Slew, float Gain, int nGatesMin, int * pnCellCount )
-{
-    char Buffer[200];
-    Vec_Str_t * vStr;
-    SC_Cell * pRepr;
-    SC_Pin * pPin;
-    int i, k, Count = 2, nClassMax = 0;
-    // find the largest number of cells in a class
-    SC_LibForEachCellClass( p, pRepr, i )
-        if ( pRepr->n_outputs == 1 )
-            nClassMax = Abc_MaxInt( nClassMax, Abc_SclClassCellNum(pRepr) );
-    // update the number
-    if ( nGatesMin && nGatesMin >= nClassMax )
-        nGatesMin = 0;
-    // mark skipped cells
-    Abc_SclMarkSkippedCells( p );
-    vStr = Vec_StrAlloc( 1000 );
-    Vec_StrPrintStr( vStr, "GATE _const0_            0.00 z=CONST0;\n" );
-    Vec_StrPrintStr( vStr, "GATE _const1_            0.00 z=CONST1;\n" );
-    SC_LibForEachCellClass( p, pRepr, i )
-    {
-        if ( pRepr->n_inputs == 0 )
-            continue;
-        if ( pRepr->n_outputs > 1 )
-            continue;
-        if ( nGatesMin && pRepr->n_inputs > 2 && Abc_SclClassCellNum(pRepr) < nGatesMin )
-            continue;
-        assert( strlen(pRepr->pName) < 200 );
-        Vec_StrPrintStr( vStr, "GATE " );
-        sprintf( Buffer, "%-16s", pRepr->pName );
-        Vec_StrPrintStr( vStr, Buffer );
-        Vec_StrPrintStr( vStr, " " );
-//        sprintf( Buffer, "%7.2f", Abc_SclComputeAreaClass(pRepr) );
-        sprintf( Buffer, "%7.2f", pRepr->area );
-        Vec_StrPrintStr( vStr, Buffer );
-        Vec_StrPrintStr( vStr, " " );
-        Vec_StrPrintStr( vStr, SC_CellPinName(pRepr, pRepr->n_inputs) );
-        Vec_StrPrintStr( vStr, "=" );
-        Vec_StrPrintStr( vStr, SC_CellPinOutFunc(pRepr, 0) ? SC_CellPinOutFunc(pRepr, 0) : "?" );
-        Vec_StrPrintStr( vStr, ";\n" );
-        SC_CellForEachPinIn( pRepr, pPin, k )
-        {
-            float Delay = Abc_SclComputeDelayClassPin( p, pRepr, k, Slew, Gain );
-            assert( Delay > 0 );
-            Vec_StrPrintStr( vStr, "         PIN " );
-            sprintf( Buffer, "%-4s", pPin->pName );
-            Vec_StrPrintStr( vStr, Buffer );
-            sprintf( Buffer, " UNKNOWN  1  999  %7.2f  0.00  %7.2f  0.00\n", Delay, Delay );
-            Vec_StrPrintStr( vStr, Buffer );
-        }
-        Count++;
-    }
-    Vec_StrPrintStr( vStr, "\n.end\n" );
-    Vec_StrPush( vStr, '\0' );
-//    printf( "GENLIB library with %d gates is produced:\n", Count );
-//    printf( "%s", Vec_StrArray(vStr) );
-    if ( pnCellCount )
-        *pnCellCount = Count;
-    return vStr;
-}
-Vec_Str_t * Abc_SclProduceGenlibStrProfile( SC_Lib * p, Mio_Library_t * pLib, float Slew, float Gain, int nGatesMin, int * pnCellCount )
-{
-    char Buffer[200];
-    Vec_Str_t * vStr;
-    SC_Cell * pRepr;
-    SC_Pin * pPin;
-    int i, k, Count = 2, nClassMax = 0;
-    // find the largest number of cells in a class
-    SC_LibForEachCellClass( p, pRepr, i )
-        if ( pRepr->n_outputs == 1 )
-            nClassMax = Abc_MaxInt( nClassMax, Abc_SclClassCellNum(pRepr) );
-    // update the number
-    if ( nGatesMin && nGatesMin >= nClassMax )
-        nGatesMin = 0;
-    // mark skipped cells
-    Abc_SclMarkSkippedCells( p );
-    vStr = Vec_StrAlloc( 1000 );
-    Vec_StrPrintStr( vStr, "GATE _const0_            0.00 z=CONST0;\n" );
-    Vec_StrPrintStr( vStr, "GATE _const1_            0.00 z=CONST1;\n" );
-    SC_LibForEachCell( p, pRepr, i )
-    {
-        if ( pRepr->n_inputs == 0 )
-            continue;
-        if ( pRepr->n_outputs > 1 )
-            continue;
-        if ( nGatesMin && pRepr->n_inputs > 2 && Abc_SclClassCellNum(pRepr) < nGatesMin )
-            continue;
-        // check if the gate is in the profile
-        if ( pRepr->n_inputs > 1 )
-        {
-            Mio_Gate_t * pGate = Mio_LibraryReadGateByName( pLib, pRepr->pName, NULL );
-            if ( pGate == NULL || Mio_GateReadProfile(pGate) == 0 )
-                continue;
-        }
-        // process gate
-        assert( strlen(pRepr->pName) < 200 );
-        Vec_StrPrintStr( vStr, "GATE " );
-        sprintf( Buffer, "%-16s", pRepr->pName );
-        Vec_StrPrintStr( vStr, Buffer );
-        Vec_StrPrintStr( vStr, " " );
-//        sprintf( Buffer, "%7.2f", Abc_SclComputeAreaClass(pRepr) );
-        sprintf( Buffer, "%7.2f", pRepr->area );
-        Vec_StrPrintStr( vStr, Buffer );
-        Vec_StrPrintStr( vStr, " " );
-        Vec_StrPrintStr( vStr, SC_CellPinName(pRepr, pRepr->n_inputs) );
-        Vec_StrPrintStr( vStr, "=" );
-        Vec_StrPrintStr( vStr, SC_CellPinOutFunc(pRepr, 0) ? SC_CellPinOutFunc(pRepr, 0) : "?" );
-        Vec_StrPrintStr( vStr, ";\n" );
-        SC_CellForEachPinIn( pRepr, pPin, k )
-        {
-            float Delay = Abc_SclComputeDelayClassPin( p, pRepr, k, Slew, Gain );
-            assert( Delay > 0 );
-            Vec_StrPrintStr( vStr, "         PIN " );
-            sprintf( Buffer, "%-4s", pPin->pName );
-            Vec_StrPrintStr( vStr, Buffer );
-            sprintf( Buffer, " UNKNOWN  1  999  %7.2f  0.00  %7.2f  0.00\n", Delay, Delay );
-            Vec_StrPrintStr( vStr, Buffer );
-        }
-        Count++;
-    }
-    Vec_StrPrintStr( vStr, "\n.end\n" );
-    Vec_StrPush( vStr, '\0' );
-//    printf( "GENLIB library with %d gates is produced:\n", Count );
-//    printf( "%s", Vec_StrArray(vStr) );
-    if ( pnCellCount )
-        *pnCellCount = Count;
-    return vStr;
-}
-void Abc_SclDumpGenlib( char * pFileName, SC_Lib * p, float SlewInit, float Gain, int nGatesMin )
-{
-    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 );
-}
-Mio_Library_t * Abc_SclDeriveGenlib( void * pScl, void * pMio, float SlewInit, float Gain, int nGatesMin, int fVerbose )
-{
-    int nCellCount = 0;
-    SC_Lib * p = (SC_Lib *)pScl;
-    float Slew = (SlewInit == 0) ? Abc_SclComputeAverageSlew(p) : SlewInit;
-    Vec_Str_t * vStr;
-    Mio_Library_t * pLib;
-    if ( pMio == NULL )
-        vStr = Abc_SclProduceGenlibStr( p, Slew, Gain, nGatesMin, &nCellCount );
-    else
-        vStr = Abc_SclProduceGenlibStrProfile( p, (Mio_Library_t *)pMio, Slew, Gain, nGatesMin, &nCellCount );
-    pLib = Mio_LibraryRead( p->pFileName, Vec_StrArray(vStr), NULL, 0 );  
-    Vec_StrFree( vStr );
-    if ( !pLib )
-        printf( "Reading library has filed.\n" );
-    else if ( fVerbose )
-        printf( "Derived GENLIB library \"%s\" with %d gates using slew %.2f ps and gain %.2f.\n", p->pName, nCellCount, Slew, Gain );
-    return pLib;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Install library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_SclInstallGenlib( void * pScl, float SlewInit, float Gain, int nGatesMin )
-{
-    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 );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-