luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

New constraint manager and memory reporting 'ps'.

This commit is contained in:
Alan Mishchenko 2015-09-08 19:53:49 -07:00
parent f623b04da4
commit 97751e43b7
16 changed files with 555 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
abclib.dsp
View File

@ -2931,6 +2931,10 @@ SOURCE=.\src\map\scl\sclBufSize.c
# End Source File
# Begin Source File
SOURCE=.\src\map\scl\sclCon.h
# End Source File
# Begin Source File
SOURCE=.\src\map\scl\sclDnsize.c
# End Source File
# Begin Source File

7
src/aig/gia/giaMan.c
View File

@ -163,6 +163,13 @@ double Gia_ManMemory( Gia_Man_t * p )
Memory += sizeof(int) * Gia_ManCoNum(p);
Memory += sizeof(int) * p->nHTable * (p->pHTable != NULL);
Memory += sizeof(int) * Gia_ManObjNum(p) * (p->pRefs != NULL);
Memory += Vec_IntMemory( p->vLevels );
Memory += Vec_IntMemory( p->vCellMapping );
Memory += Vec_IntMemory( &p->vCopies );
Memory += Vec_FltMemory( p->vInArrs );
Memory += Vec_FltMemory( p->vOutReqs );
Memory += Vec_PtrMemory( p->vNamesIn );
Memory += Vec_PtrMemory( p->vNamesOut );
return Memory;
}

29
src/aig/gia/giaNf.c
View File

@ -28,6 +28,8 @@
#include "misc/vec/vecMem.h"
#include "misc/vec/vecWec.h"
#include "opt/dau/dau.h"
#include "misc/util/utilNam.h"
#include "map/scl/sclCon.h"
ABC_NAMESPACE_IMPL_START
@ -110,6 +112,8 @@ struct Nf_Man_t_
static inline int Pf_Mat2Int( Pf_Mat_t Mat ) { union { int x; Pf_Mat_t y; } v; v.y = Mat; return v.x; }
static inline Pf_Mat_t Pf_Int2Mat( int Int ) { union { int x; Pf_Mat_t y; } v; v.x = Int; return v.y; }
static inline word Nf_Flt2Wrd( float w ) { return MIO_NUMINV*w; }
static inline float Nf_Wrd2Flt( word w ) { return MIO_NUMINV*(unsigned)(w&0x3FFFFFFF) + MIO_NUMINV*(1<<30)*(unsigned)(w>>30); }
static inline Nf_Obj_t * Nf_ManObj( Nf_Man_t * p, int i ) { return p->pNfObjs + i; }
@ -1396,6 +1400,7 @@ void Nf_ManSetOutputRequireds( Nf_Man_t * p, int fPropCompl )
{
Gia_Obj_t * pObj;
word Required = 0;
int fUseConMan = Scl_ConIsRunning() && Scl_ConHasOutReqs();
int i, iObj, fCompl, nLits = 2*Gia_ManObjNum(p->pGia);
Vec_WrdFill( &p->vRequired, nLits, NF_INFINITY );
// compute delay
@ -1424,8 +1429,16 @@ void Nf_ManSetOutputRequireds( Nf_Man_t * p, int fPropCompl )
Required = Nf_ObjMatchD(p, iObj, fCompl)->D;
Required = p->pPars->fDoAverage ? Required * (100 + p->pPars->nRelaxRatio) / 100 : p->pPars->WordMapDelay;
// if external required time can be achieved, use it
if ( p->pGia->vOutReqs && Vec_FltEntry(p->pGia->vOutReqs, i) > 0 && Required <= (word)(MIO_NUM * Vec_FltEntry(p->pGia->vOutReqs, i)) )
Required = (word)(MIO_NUM * Vec_FltEntry(p->pGia->vOutReqs, i));
if ( fUseConMan )
{
if ( Scl_ConGetOutReq(i) > 0 && Required <= Scl_ConGetOutReq(i) )
Required = Scl_ConGetOutReq(i);
}
else
{
if ( p->pGia->vOutReqs && Vec_FltEntry(p->pGia->vOutReqs, i) > 0 && Required <= Nf_Flt2Wrd(Vec_FltEntry(p->pGia->vOutReqs, i)) )
Required = Nf_Flt2Wrd(Vec_FltEntry(p->pGia->vOutReqs, i));
}
// if external required cannot be achieved, set the earliest possible arrival time
// else if ( p->pGia->vOutReqs && Vec_FltEntry(p->pGia->vOutReqs, i) > 0 && Required > Vec_FltEntry(p->pGia->vOutReqs, i) )
// ptTime->Rise = ptTime->Fall = ptTime->Worst = Required;
@ -2169,8 +2182,16 @@ Gia_Man_t * Nf_ManPerformMapping( Gia_Man_t * pGia, Jf_Par_t * pPars )
Nf_ManPrintInit( p );
Nf_ManComputeCuts( p );
Nf_ManPrintQuit( p );
Gia_ManForEachCiId( p->pGia, Id, i )
Nf_ObjPrepareCi( p, Id, p->pGia->vInArrs ? Vec_FltEntry(p->pGia->vInArrs, i) : 0.0 );
if ( Scl_ConIsRunning() )
{
Gia_ManForEachCiId( p->pGia, Id, i )
Nf_ObjPrepareCi( p, Id, Scl_ConGetInArr(i) );
}
else
{
Gia_ManForEachCiId( p->pGia, Id, i )
Nf_ObjPrepareCi( p, Id, Nf_Flt2Wrd(p->pGia->vInArrs ? Vec_FltEntry(p->pGia->vInArrs, i) : 0.0) );
}
for ( p->Iter = 0; p->Iter < p->pPars->nRounds; p->Iter++ )
{
Nf_ManComputeMapping( p );

2
src/base/abc/abc.h
View File

@ -813,7 +813,7 @@ extern ABC_DLL void Abc_NtkDontCareFree( Odc_Man_t * p );
extern ABC_DLL int Abc_NtkDontCareCompute( Odc_Man_t * p, Abc_Obj_t * pNode, Vec_Ptr_t * vLeaves, unsigned * puTruth );
/*=== abcPrint.c ==========================================================*/
extern ABC_DLL float Abc_NtkMfsTotalSwitching( Abc_Ntk_t * pNtk );
extern ABC_DLL void Abc_NtkPrintStats( Abc_Ntk_t * pNtk, int fFactored, int fSaveBest, int fDumpResult, int fUseLutLib, int fPrintMuxes, int fPower, int fGlitch, int fSkipBuf );
extern ABC_DLL void Abc_NtkPrintStats( Abc_Ntk_t * pNtk, int fFactored, int fSaveBest, int fDumpResult, int fUseLutLib, int fPrintMuxes, int fPower, int fGlitch, int fSkipBuf, int fPrintMem );
extern ABC_DLL void Abc_NtkPrintIo( FILE * pFile, Abc_Ntk_t * pNtk, int fPrintFlops );
extern ABC_DLL void Abc_NtkPrintLatch( FILE * pFile, Abc_Ntk_t * pNtk );
extern ABC_DLL void Abc_NtkPrintFanio( FILE * pFile, Abc_Ntk_t * pNtk, int fUsePis );

2
src/base/abc/abcHie.c
View File

@ -470,7 +470,7 @@ void Abc_NtkPrintBoxInfo( Abc_Ntk_t * pNtk )
Vec_IntAddToEntry( vCounts, Num, 1 );
}
// Abc_NtkPrintStats( pModel, 0, 0, 0, 0, 0, 0, 0, 0 );
// Abc_NtkPrintStats( pModel, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
printf( "MODULE " );
printf( "%-30s : ", Abc_NtkName(pModel) );
printf( "PI=%6d ", Abc_NtkPiNum(pModel) );

44
src/base/abc/abcNames.c
View File

@ -353,6 +353,39 @@ void Abc_NtkOrderObjsByName( Abc_Ntk_t * pNtk, int fComb )
pObj->pCopy = NULL;
}
/**Function*************************************************************
Synopsis [Creates name manager storing input/output names.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Nam_t * Abc_NtkNameMan( Abc_Ntk_t * p, int fOuts )
{
if ( fOuts )
{
Abc_Obj_t * pObj; int i;
Abc_Nam_t * pStrsCo = Abc_NamStart( Abc_NtkCoNum(p), 24 );
Abc_NtkForEachCo( p, pObj, i )
Abc_NamStrFindOrAdd( pStrsCo, Abc_ObjName(pObj), NULL );
assert( Abc_NamObjNumMax(pStrsCo) == i + 1 );
return pStrsCo;
}
else
{
Abc_Obj_t * pObj; int i;
Abc_Nam_t * pStrsCi = Abc_NamStart( Abc_NtkCiNum(p), 24 );
Abc_NtkForEachCi( p, pObj, i )
Abc_NamStrFindOrAdd( pStrsCi, Abc_ObjName(pObj), NULL );
assert( Abc_NamObjNumMax(pStrsCi) == i + 1 );
return pStrsCi;
}
}
/**Function*************************************************************
Synopsis [Orders PIs/POs/latches alphabetically.]
@ -376,18 +409,11 @@ int Abc_NodeCompareIndexes( Abc_Obj_t ** pp1, Abc_Obj_t ** pp2 )
void Abc_NtkTransferOrder( Abc_Ntk_t * pNtkOld, Abc_Ntk_t * pNtkNew )
{
Abc_Obj_t * pObj; int i;
Abc_Nam_t * pStrsCi = Abc_NamStart( Abc_NtkCiNum(pNtkOld), 24 );
Abc_Nam_t * pStrsCo = Abc_NamStart( Abc_NtkCoNum(pNtkOld), 24 );
Abc_Nam_t * pStrsCi = Abc_NtkNameMan( pNtkOld, 0 );
Abc_Nam_t * pStrsCo = Abc_NtkNameMan( pNtkOld, 1 );
assert( Abc_NtkPiNum(pNtkOld) == Abc_NtkPiNum(pNtkNew) );
assert( Abc_NtkPoNum(pNtkOld) == Abc_NtkPoNum(pNtkNew) );
assert( Abc_NtkLatchNum(pNtkOld) == Abc_NtkLatchNum(pNtkNew) );
// save IDs of the names
Abc_NtkForEachCi( pNtkOld, pObj, i )
Abc_NamStrFindOrAdd( pStrsCi, Abc_ObjName(pObj), NULL );
assert( Abc_NamObjNumMax(pStrsCi) == i + 1 );
Abc_NtkForEachCo( pNtkOld, pObj, i )
Abc_NamStrFindOrAdd( pStrsCo, Abc_ObjName(pObj), NULL );
assert( Abc_NamObjNumMax(pStrsCo) == i + 1 );
// transfer to the new network
Abc_NtkForEachCi( pNtkNew, pObj, i )
{

14
src/base/abci/abc.c
View File

@ -1184,6 +1184,7 @@ int Abc_CommandPrintStats( Abc_Frame_t * pAbc, int argc, char ** argv )
int fPower;
int fGlitch;
int fSkipBuf;
int fPrintMem;
int c;
pNtk = Abc_FrameReadNtk(pAbc);
@ -1198,8 +1199,9 @@ int Abc_CommandPrintStats( Abc_Frame_t * pAbc, int argc, char ** argv )
fPower = 0;
fGlitch = 0;
fSkipBuf = 0;
fPrintMem = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "fbdltmpgsh" ) ) != EOF )
while ( ( c = Extra_UtilGetopt( argc, argv, "fbdltmpgsuh" ) ) != EOF )
{
switch ( c )
{
@ -1230,6 +1232,9 @@ int Abc_CommandPrintStats( Abc_Frame_t * pAbc, int argc, char ** argv )
case 's':
fSkipBuf ^= 1;
break;
case 'u':
fPrintMem ^= 1;
break;
case 'h':
goto usage;
default:
@ -1247,7 +1252,7 @@ int Abc_CommandPrintStats( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( -1, "Cannot print LUT delay for a non-logic network.\n" );
return 1;
}
Abc_NtkPrintStats( pNtk, fFactor, fSaveBest, fDumpResult, fUseLutLib, fPrintMuxes, fPower, fGlitch, fSkipBuf );
Abc_NtkPrintStats( pNtk, fFactor, fSaveBest, fDumpResult, fUseLutLib, fPrintMuxes, fPower, fGlitch, fSkipBuf, fPrintMem );
if ( fPrintTime )
{
pAbc->TimeTotal += pAbc->TimeCommand;
@ -1257,7 +1262,7 @@ int Abc_CommandPrintStats( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0;
usage:
Abc_Print( -2, "usage: print_stats [-fbdltmpgsh]\n" );
Abc_Print( -2, "usage: print_stats [-fbdltmpgsuh]\n" );
Abc_Print( -2, "\t prints the network statistics\n" );
Abc_Print( -2, "\t-f : toggles printing the literal count in the factored forms [default = %s]\n", fFactor? "yes": "no" );
Abc_Print( -2, "\t-b : toggles saving the best logic network in \"best.blif\" [default = %s]\n", fSaveBest? "yes": "no" );
@ -1268,6 +1273,7 @@ usage:
Abc_Print( -2, "\t-p : toggles printing power dissipation due to switching [default = %s]\n", fPower? "yes": "no" );
Abc_Print( -2, "\t-g : toggles printing percentage of increased power due to glitching [default = %s]\n", fGlitch? "yes": "no" );
Abc_Print( -2, "\t-s : toggles not counting single-output nodes as nodes [default = %s]\n", fSkipBuf? "yes": "no" );
Abc_Print( -2, "\t-u : toggles printing memory usage [default = %s]\n", fPrintMem? "yes": "no" );
Abc_Print( -2, "\t-h : print the command usage\n");
return 1;
}
@ -1348,7 +1354,7 @@ int Abc_CommandPrintExdc( Abc_Frame_t * pAbc, int argc, char ** argv )
}
else
Abc_Print( 1, "EXDC network statistics: \n" );
Abc_NtkPrintStats( pNtk->pExdc, 0, 0, 0, 0, 0, 0, 0, 0 );
Abc_NtkPrintStats( pNtk->pExdc, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
return 0;
usage:

2
src/base/abci/abcMini.c
View File

@ -195,7 +195,7 @@ void Abc_NtkMiniAigTest( Abc_Ntk_t * pNtk )
p = Abc_NtkToMiniAig( pNtk );
pNtkNew = Abc_NtkFromMiniAig( p );
Mini_AigStop( p );
Abc_NtkPrintStats( pNtkNew, 0, 0, 0, 0, 0, 0, 0, 0 );
Abc_NtkPrintStats( pNtkNew, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
Abc_NtkDelete( pNtkNew );
// test dumping

34
src/base/abci/abcPrint.c
View File

@ -121,6 +121,34 @@ int Abc_NtkCompareAndSaveBest( Abc_Ntk_t * pNtk )
return 0;
}
/**Function*************************************************************
Synopsis [Collects memory usage.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
double Abc_NtkMemory( Abc_Ntk_t * p )
{
Abc_Obj_t * pObj; int i;
double Memory = sizeof(Abc_Ntk_t);
Memory += sizeof(Abc_Obj_t) * Abc_NtkObjNum(p);
Memory += Vec_PtrMemory(p->vPis);
Memory += Vec_PtrMemory(p->vPos);
Memory += Vec_PtrMemory(p->vCis);
Memory += Vec_PtrMemory(p->vCos);
Memory += Vec_PtrMemory(p->vObjs);
Memory += Vec_IntMemory(&p->vTravIds);
Memory += Vec_IntMemory(p->vLevelsR);
Abc_NtkForEachObj( p, pObj, i )
Memory += sizeof(int) * (Vec_IntCap(&pObj->vFanins) + Vec_IntCap(&pObj->vFanouts));
return Memory;
}
/**Function*************************************************************
Synopsis [Marks nodes for power-optimization.]
@ -207,7 +235,7 @@ float Abc_NtkGetArea( Abc_Ntk_t * pNtk )
SeeAlso []
***********************************************************************/
void Abc_NtkPrintStats( Abc_Ntk_t * pNtk, int fFactored, int fSaveBest, int fDumpResult, int fUseLutLib, int fPrintMuxes, int fPower, int fGlitch, int fSkipBuf )
void Abc_NtkPrintStats( Abc_Ntk_t * pNtk, int fFactored, int fSaveBest, int fDumpResult, int fUseLutLib, int fPrintMuxes, int fPower, int fGlitch, int fSkipBuf, int fPrintMem )
{
int nSingles = fSkipBuf ? Abc_NtkGetBufNum(pNtk) : 0;
if ( fPrintMuxes && Abc_NtkIsStrash(pNtk) )
@ -329,6 +357,8 @@ void Abc_NtkPrintStats( Abc_Ntk_t * pNtk, int fFactored, int fSaveBest, int fDum
else
printf( "\nCurrently computes glitching only for K-LUT networks with K <= 6." );
}
if ( fPrintMem )
Abc_Print( 1," mem =%5.2f MB", Abc_NtkMemory(pNtk)/(1<<20) );
Abc_Print( 1,"\n" );
// print the statistic into a file
@ -425,7 +455,7 @@ void Abc_NtkPrintStats( Abc_Ntk_t * pNtk, int fFactored, int fSaveBest, int fDum
fflush( stdout );
if ( pNtk->pExdc )
Abc_NtkPrintStats( pNtk->pExdc, fFactored, fSaveBest, fDumpResult, fUseLutLib, fPrintMuxes, fPower, fGlitch, fSkipBuf );
Abc_NtkPrintStats( pNtk->pExdc, fFactored, fSaveBest, fDumpResult, fUseLutLib, fPrintMuxes, fPower, fGlitch, fSkipBuf, fPrintMem );
}
/**Function*************************************************************

1
src/base/main/mainInt.h
View File

@ -94,6 +94,7 @@ struct Abc_Frame_t_
void * pLibGen2; // the current genlib
void * pLibSuper; // the current supergate library
void * pLibScl; // the current Liberty library
void * pAbcCon; // constraint manager
// timing constraints
char * pDrivingCell; // name of the driving cell
float MaxLoad; // maximum output load

13
src/map/mapper/mapperMatch.c
View File

@ -18,6 +18,9 @@
#include "mapperInt.h"
#include "misc/util/utilNam.h"
#include "map/scl/sclCon.h"
ABC_NAMESPACE_IMPL_START
@ -356,7 +359,15 @@ void Map_MappingSetPiArrivalTimes( Map_Man_t * p )
{
pNode = p->pInputs[i];
// set the arrival time of the positive phase
pNode->tArrival[1] = p->pInputArrivals[i];
if ( Scl_ConIsRunning() )
{
float Time = Scl_ConGetInArrFloat( i );
pNode->tArrival[1].Fall = Time;
pNode->tArrival[1].Rise = Time;
pNode->tArrival[1].Worst = Time;
}
else
pNode->tArrival[1] = p->pInputArrivals[i];
pNode->tArrival[1].Rise += p->pNodeDelays ? p->pNodeDelays[pNode->Num] : 0;
pNode->tArrival[1].Fall += p->pNodeDelays ? p->pNodeDelays[pNode->Num] : 0;
pNode->tArrival[1].Worst += p->pNodeDelays ? p->pNodeDelays[pNode->Num] : 0;

38
src/map/mapper/mapperTime.c
View File

@ -18,6 +18,9 @@
#include "mapperInt.h"
#include "misc/util/utilNam.h"
#include "map/scl/sclCon.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
@ -381,8 +384,9 @@ void Map_TimePropagateRequired( Map_Man_t * p )
}
void Map_TimeComputeRequiredGlobal( Map_Man_t * p )
{
int fUseConMan = Scl_ConIsRunning() && Scl_ConHasOutReqs();
Map_Time_t * ptTime, * ptTimeA;
int fPhase, i;
int fPhase, i;
// update the required times according to the target
p->fRequiredGlo = Map_TimeComputeArrivalMax( p );
if ( p->DelayTarget != -1 )
@ -416,15 +420,31 @@ void Map_TimeComputeRequiredGlobal( Map_Man_t * p )
ptTime = Map_Regular(p->pOutputs[i])->tRequired + fPhase;
ptTimeA = Map_Regular(p->pOutputs[i])->tArrival + fPhase;
// if external required time can be achieved, use it
if ( p->pOutputRequireds && p->pOutputRequireds[i].Worst > 0 && ptTimeA->Worst <= p->pOutputRequireds[i].Worst )//&& p->pOutputRequireds[i].Worst <= p->fRequiredGlo )
ptTime->Rise = ptTime->Fall = ptTime->Worst = p->pOutputRequireds[i].Worst;
// if external required cannot be achieved, set the earliest possible arrival time
else if ( p->pOutputRequireds && p->pOutputRequireds[i].Worst > 0 && ptTimeA->Worst > p->pOutputRequireds[i].Worst )
ptTime->Rise = ptTime->Fall = ptTime->Worst = ptTimeA->Worst;
// otherwise, set the global required time
if ( fUseConMan )
{
float Value = Scl_ConGetOutReqFloat(i);
// if external required time can be achieved, use it
if ( Value > 0 && ptTimeA->Worst <= Value )//&& Value <= p->fRequiredGlo )
ptTime->Rise = ptTime->Fall = ptTime->Worst = Value;
// if external required cannot be achieved, set the earliest possible arrival time
else if ( Value > 0 && ptTimeA->Worst > Value )
ptTime->Rise = ptTime->Fall = ptTime->Worst = ptTimeA->Worst;
// otherwise, set the global required time
else
ptTime->Rise = ptTime->Fall = ptTime->Worst = p->fRequiredGlo;
}
else
ptTime->Rise = ptTime->Fall = ptTime->Worst = p->fRequiredGlo;
{
// if external required time can be achieved, use it
if ( p->pOutputRequireds && p->pOutputRequireds[i].Worst > 0 && ptTimeA->Worst <= p->pOutputRequireds[i].Worst )//&& p->pOutputRequireds[i].Worst <= p->fRequiredGlo )
ptTime->Rise = ptTime->Fall = ptTime->Worst = p->pOutputRequireds[i].Worst;
// if external required cannot be achieved, set the earliest possible arrival time
else if ( p->pOutputRequireds && p->pOutputRequireds[i].Worst > 0 && ptTimeA->Worst > p->pOutputRequireds[i].Worst )
ptTime->Rise = ptTime->Fall = ptTime->Worst = ptTimeA->Worst;
// otherwise, set the global required time
else
ptTime->Rise = ptTime->Fall = ptTime->Worst = p->fRequiredGlo;
}
}
// visit nodes in the reverse topological order
Map_TimePropagateRequired( p );

94
src/map/scl/scl.c
View File

@ -21,6 +21,9 @@
#include "sclSize.h"
#include "base/main/mainInt.h"
#include "misc/util/utilNam.h"
#include "sclCon.h"
ABC_NAMESPACE_IMPL_START
@ -47,9 +50,15 @@ static int Scl_CommandUpsize ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Scl_CommandDnsize ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Scl_CommandPrintBuf ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Scl_CommandReadConstr ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Scl_CommandWriteConstr( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Scl_CommandPrintConstr( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Scl_CommandResetConstr( Abc_Frame_t * pAbc, int argc, char ** argv );
static inline Scl_Con_t * Scl_ConGetMan( Abc_Frame_t * pAbc ) { return (Scl_Con_t *)pAbc->pAbcCon; }
static inline void Scl_ConFreeMan( Abc_Frame_t * pAbc ) { if ( pAbc->pAbcCon ) Scl_ConFree(Scl_ConGetMan(pAbc)); }
static inline void Scl_ConUpdateMan( Abc_Frame_t * pAbc, Scl_Con_t * p ) { Scl_ConFreeMan(pAbc); pAbc->pAbcCon = p; }
Scl_Con_t * Scl_ConReadMan() { return Scl_ConGetMan( Abc_FrameGetGlobalFrame() ); }
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
@ -109,12 +118,14 @@ void Scl_Init( Abc_Frame_t * pAbc )
Cmd_CommandAdd( pAbc, "SCL mapping", "dnsize", Scl_CommandDnsize, 1 );
Cmd_CommandAdd( pAbc, "SCL mapping", "print_buf", Scl_CommandPrintBuf, 0 );
Cmd_CommandAdd( pAbc, "SCL mapping", "read_constr", Scl_CommandReadConstr, 0 );
Cmd_CommandAdd( pAbc, "SCL mapping", "write_constr", Scl_CommandWriteConstr, 0 );
Cmd_CommandAdd( pAbc, "SCL mapping", "print_constr", Scl_CommandPrintConstr, 0 );
Cmd_CommandAdd( pAbc, "SCL mapping", "reset_constr", Scl_CommandResetConstr, 0 );
}
void Scl_End( Abc_Frame_t * pAbc )
{
Abc_SclLoad( NULL, (SC_Lib **)&pAbc->pLibScl );
Scl_ConUpdateMan( pAbc, NULL );
}
@ -1799,7 +1810,9 @@ usage:
***********************************************************************/
int Scl_CommandReadConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
{
extern Abc_Nam_t * Abc_NtkNameMan( Abc_Ntk_t * p, int fOuts );
extern void Abc_SclReadTimingConstr( Abc_Frame_t * pAbc, char * pFileName, int fVerbose );
Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
FILE * pFile;
char * pFileName;
int c, fVerbose = 0;
@ -1830,6 +1843,13 @@ int Scl_CommandReadConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
}
fclose( pFile );
Abc_SclReadTimingConstr( pAbc, pFileName, fVerbose );
// input constraint manager
if ( pNtk )
{
Scl_Con_t * pCon = Scl_ConRead( pFileName, Abc_NtkNameMan(pNtk, 0), Abc_NtkNameMan(pNtk, 1) );
if ( pCon ) Scl_ConUpdateMan( pAbc, pCon );
}
return 0;
usage:
@ -1852,8 +1872,10 @@ usage:
SeeAlso []
***********************************************************************/
int Scl_CommandPrintConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
int Scl_CommandWriteConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
{
Scl_Con_t * pCon = Scl_ConGetMan( pAbc );
char * pFileName = NULL;
int c, fVerbose = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
@ -1869,8 +1891,72 @@ int Scl_CommandPrintConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
goto usage;
}
}
printf( "Primary input driving cell = %s\n", Abc_FrameReadDrivingCell() );
printf( "Primary output maximum load = %f\n", Abc_FrameReadMaxLoad() );
if ( pCon == NULL )
{
Abc_Print( 1, "Scl_CommandWriteConstr(): There is no constraint manager.\n" );
return 0;
}
if ( argc == globalUtilOptind + 1 )
pFileName = argv[globalUtilOptind];
else if ( argc == globalUtilOptind && pCon )
pFileName = Extra_FileNameGenericAppend( pCon->pFileName, "_out.constr" );
else
{
printf( "Output file name should be given on the command line.\n" );
return 0;
}
// perform writing
if ( !strcmp( Extra_FileNameExtension(pFileName), "constr" ) )
Scl_ConWrite( pCon, pFileName );
else
{
printf( "Scl_CommandWriteConstr(): Unrecognized output file extension.\n" );
return 0;
}
return 0;
usage:
fprintf( pAbc->Err, "usage: write_constr [-vh] <file>\n" );
fprintf( pAbc->Err, "\t writes current timing constraints into a file\n" );
fprintf( pAbc->Err, "\t-v : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
fprintf( pAbc->Err, "\t-h : prints the command summary\n" );
fprintf( pAbc->Err, "\t<file> : the name of a file to read\n" );
return 1;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Scl_CommandPrintConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
{
Scl_Con_t * pCon = Scl_ConGetMan( pAbc );
int c, fVerbose = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
{
switch ( c )
{
case 'v':
fVerbose ^= 1;
break;
case 'h':
goto usage;
default:
goto usage;
}
}
//printf( "Primary input driving cell = %s\n", Abc_FrameReadDrivingCell() );
//printf( "Primary output maximum load = %f\n", Abc_FrameReadMaxLoad() );
if ( pCon ) Scl_ConWrite( pCon, NULL );
return 0;
usage:
@ -1912,6 +1998,8 @@ int Scl_CommandResetConstr( Abc_Frame_t * pAbc, int argc, char ** argv )
}
Abc_FrameSetDrivingCell( NULL );
Abc_FrameSetMaxLoad( 0 );
Scl_ConUpdateMan( pAbc, NULL );
return 0;
usage:

289
src/map/scl/sclCon.h Normal file
View File

@ -0,0 +1,289 @@
/**CFile****************************************************************
FileName [sclCon.h]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Standard-cell library representation.]
Synopsis [Constraint manager.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - August 24, 2012.]
Revision [$Id: sclCon.h,v 1.0 2012/08/24 00:00:00 alanmi Exp $]
***********************************************************************/
ABC_NAMESPACE_HEADER_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
typedef struct Scl_Con_t_ Scl_Con_t;
struct Scl_Con_t_
{
char * pFileName; // constraint file name
char * pModelName; // current design name
char * pInCellDef; // default input driving gate
word tInArrDef; // default input arrival time
word tInSlewDef; // default input slew
word tInLoadDef; // default input load
word tOutReqDef; // default output required time
word tOutLoadDef; // default output load
Vec_Ptr_t vInCells; // input driving gates
Vec_Wrd_t vInArrs; // input arrival times
Vec_Wrd_t vInSlews; // input slews
Vec_Wrd_t vInLoads; // input loads
Vec_Wrd_t vOutReqs; // output required times
Vec_Wrd_t vOutLoads; // output loads
Abc_Nam_t * pNamI; // input names
Abc_Nam_t * pNamO; // output names
};
#define SCL_INPUT_CELL "input_cell"
#define SCL_INPUT_ARR "input_arrival"
#define SCL_INPUT_SLEW "input_slew"
#define SCL_INPUT_LOAD "input_load"
#define SCL_OUTPUT_REQ "output_required"
#define SCL_OUTPUT_LOAD "output_load"
#define SCL_DIRECTIVE(ITEM) "."ITEM
#define SCL_DEF_DIRECTIVE(ITEM) ".default_"ITEM
#define SCL_NUM 1000000
#define SCL_NUMINV 0.000001
#define SCL_INFINITY (~(word)0)
static inline word Scl_Flt2Wrd( float w ) { return SCL_NUM*w; }
static inline float Scl_Wrd2Flt( word w ) { return SCL_NUMINV*(unsigned)(w&0x3FFFFFFF) + SCL_NUMINV*(1<<30)*(unsigned)(w>>30); }
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Manager construction.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline Scl_Con_t * Scl_ConAlloc( char * pFileName, Abc_Nam_t * pNamI, Abc_Nam_t * pNamO )
{
Scl_Con_t * p = ABC_CALLOC( Scl_Con_t, 1 );
p->pFileName = Abc_UtilStrsav( pFileName );
p->pNamI = pNamI;
p->pNamO = pNamO;
p->pModelName = NULL;
p->pInCellDef = NULL;
p->tInArrDef = SCL_INFINITY;
p->tInSlewDef = SCL_INFINITY;
p->tInLoadDef = SCL_INFINITY;
p->tOutReqDef = SCL_INFINITY;
p->tOutLoadDef = SCL_INFINITY;
Vec_PtrFill( &p->vInCells, Abc_NamObjNumMax(pNamI)-1, NULL );
Vec_WrdFill( &p->vInArrs, Abc_NamObjNumMax(pNamI)-1, SCL_INFINITY );
Vec_WrdFill( &p->vInSlews, Abc_NamObjNumMax(pNamI)-1, SCL_INFINITY );
Vec_WrdFill( &p->vInLoads, Abc_NamObjNumMax(pNamI)-1, SCL_INFINITY );
Vec_WrdFill( &p->vOutReqs, Abc_NamObjNumMax(pNamO)-1, SCL_INFINITY );
Vec_WrdFill( &p->vOutLoads, Abc_NamObjNumMax(pNamO)-1, SCL_INFINITY );
return p;
}
static inline void Scl_ConFree( Scl_Con_t * p )
{
Vec_PtrFreeData( &p->vInCells );
Vec_PtrErase( &p->vInCells );
Vec_WrdErase( &p->vInArrs );
Vec_WrdErase( &p->vInSlews );
Vec_WrdErase( &p->vInLoads );
Vec_WrdErase( &p->vOutReqs );
Vec_WrdErase( &p->vOutLoads );
Abc_NamDeref( p->pNamI );
Abc_NamDeref( p->pNamO );
ABC_FREE( p->pInCellDef );
ABC_FREE( p->pModelName );
ABC_FREE( p->pFileName );
ABC_FREE( p );
}
/**Function*************************************************************
Synopsis [Manager serialization.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Scl_ConParse( Scl_Con_t * p, Abc_Nam_t * pNamI, Abc_Nam_t * pNamO )
{
char Buffer[1000];
char * pToken, * pToken2, * pToken3, * pName;
int i, Num = -1, nLines = 0; word Value;
FILE * pFile = fopen( p->pFileName, "rb" );
while ( fgets( Buffer, 1000, pFile ) )
{
nLines++;
pToken = strtok( Buffer, " \t\r\n" );
if ( pToken == NULL )
continue;
pToken2 = strtok( NULL, " \t\r\n" );
if ( pToken2 == NULL )
{
printf( "Line %d: Skipping directive \"%s\" without argument.\n", nLines, pToken );
continue;
}
pToken3 = strtok( NULL, " \t\r\n" );
if ( !strcmp(pToken, ".model") ) p->pModelName = Abc_UtilStrsav(pToken2);
else if ( !strcmp(pToken, SCL_DEF_DIRECTIVE(SCL_INPUT_CELL)) ) p->pInCellDef = Abc_UtilStrsav(pToken2);
else if ( !strcmp(pToken, SCL_DEF_DIRECTIVE(SCL_INPUT_ARR)) ) p->tInArrDef = Scl_Flt2Wrd(atof(pToken2));
else if ( !strcmp(pToken, SCL_DEF_DIRECTIVE(SCL_INPUT_SLEW)) ) p->tInSlewDef = Scl_Flt2Wrd(atof(pToken2));
else if ( !strcmp(pToken, SCL_DEF_DIRECTIVE(SCL_INPUT_LOAD)) ) p->tInLoadDef = Scl_Flt2Wrd(atof(pToken2));
else if ( !strcmp(pToken, SCL_DEF_DIRECTIVE(SCL_OUTPUT_REQ)) ) p->tOutReqDef = Scl_Flt2Wrd(atof(pToken2));
else if ( !strcmp(pToken, SCL_DEF_DIRECTIVE(SCL_OUTPUT_LOAD))) p->tOutLoadDef = Scl_Flt2Wrd(atof(pToken2));
else if ( pToken3 == NULL ) { printf( "Directive %s should be followed by two arguments.\n", pToken ); continue; }
else if ( !strcmp(pToken, SCL_DIRECTIVE(SCL_INPUT_CELL)) ) if ( (Num = Abc_NamStrFind(pNamI, pToken2)) > 0 ) Vec_PtrWriteEntry( &p->vInCells, Num-1, Abc_UtilStrsav(pToken3) ); else printf( "Line %d: Cannot find input \"%s\".\n", nLines, pToken2 );
else if ( !strcmp(pToken, SCL_DIRECTIVE(SCL_INPUT_ARR)) ) if ( (Num = Abc_NamStrFind(pNamI, pToken2)) > 0 ) Vec_WrdWriteEntry( &p->vInArrs, Num-1, Scl_Flt2Wrd(atof(pToken3)) ); else printf( "Line %d: Cannot find input \"%s\".\n", nLines, pToken2 );
else if ( !strcmp(pToken, SCL_DIRECTIVE(SCL_INPUT_SLEW)) ) if ( (Num = Abc_NamStrFind(pNamI, pToken2)) > 0 ) Vec_WrdWriteEntry( &p->vInSlews, Num-1, Scl_Flt2Wrd(atof(pToken3)) ); else printf( "Line %d: Cannot find input \"%s\".\n", nLines, pToken2 );
else if ( !strcmp(pToken, SCL_DIRECTIVE(SCL_INPUT_LOAD)) ) if ( (Num = Abc_NamStrFind(pNamI, pToken2)) > 0 ) Vec_WrdWriteEntry( &p->vInLoads, Num-1, Scl_Flt2Wrd(atof(pToken3)) ); else printf( "Line %d: Cannot find input \"%s\".\n", nLines, pToken2 );
else if ( !strcmp(pToken, SCL_DIRECTIVE(SCL_OUTPUT_REQ)) ) if ( (Num = Abc_NamStrFind(pNamO, pToken2)) > 0 ) Vec_WrdWriteEntry( &p->vOutReqs, Num-1, Scl_Flt2Wrd(atof(pToken3)) ); else printf( "Line %d: Cannot find output \"%s\".\n", nLines, pToken2 );
else if ( !strcmp(pToken, SCL_DIRECTIVE(SCL_OUTPUT_LOAD)) ) if ( (Num = Abc_NamStrFind(pNamO, pToken2)) > 0 ) Vec_WrdWriteEntry( &p->vOutLoads, Num-1, Scl_Flt2Wrd(atof(pToken3)) ); else printf( "Line %d: Cannot find output \"%s\".\n", nLines, pToken2 );
else printf( "Line %d: Skipping unrecognized directive \"%s\".\n", nLines, pToken );
}
// set missing defaults
if ( p->pInCellDef == NULL ) p->pInCellDef = NULL; // consider using buffer from the current library
if ( p->tInArrDef == SCL_INFINITY ) p->tInArrDef = 0;
if ( p->tInSlewDef == SCL_INFINITY ) p->tInSlewDef = 0;
if ( p->tInLoadDef == SCL_INFINITY ) p->tInLoadDef = 0;
if ( p->tOutReqDef == SCL_INFINITY ) p->tOutReqDef = 0;
if ( p->tOutLoadDef == SCL_INFINITY ) p->tOutLoadDef = 0;
// set individual defaults
if ( p->pInCellDef )
Vec_PtrForEachEntry(char *, &p->vInCells, pName, i) if ( pName == NULL ) Vec_PtrWriteEntry( &p->vInCells, i, Abc_UtilStrsav(p->pInCellDef) );
Vec_WrdForEachEntry( &p->vInArrs, Value, i ) if ( Value == SCL_INFINITY ) Vec_WrdWriteEntry( &p->vInArrs, i, p->tInArrDef );
Vec_WrdForEachEntry( &p->vInSlews, Value, i ) if ( Value == SCL_INFINITY ) Vec_WrdWriteEntry( &p->vInSlews, i, p->tInSlewDef );
Vec_WrdForEachEntry( &p->vInLoads, Value, i ) if ( Value == SCL_INFINITY ) Vec_WrdWriteEntry( &p->vInLoads, i, p->tInLoadDef );
Vec_WrdForEachEntry( &p->vOutReqs, Value, i ) if ( Value == SCL_INFINITY ) Vec_WrdWriteEntry( &p->vOutReqs, i, p->tOutReqDef );
Vec_WrdForEachEntry( &p->vOutLoads, Value, i ) if ( Value == SCL_INFINITY ) Vec_WrdWriteEntry( &p->vOutLoads, i, p->tOutLoadDef );
fclose( pFile );
return 1;
}
static inline Scl_Con_t * Scl_ConRead( char * pFileName, Abc_Nam_t * pNamI, Abc_Nam_t * pNamO )
{
Scl_Con_t * p = Scl_ConAlloc( pFileName, pNamI, pNamO );
if ( Scl_ConParse(p, pNamI, pNamO) )
return p;
Scl_ConFree( p );
return NULL;
}
static inline void Scl_ConWrite( Scl_Con_t * p, char * pFileName )
{
char * pName; word Value; int i;
FILE * pFile = pFileName ? fopen( pFileName, "wb" ) : stdout;
if ( pFile == NULL )
{
printf( "Cannot open output file \"%s\".\n", pFileName );
return;
}
fprintf( pFile, ".model %s\n", p->pModelName );
if ( p->pInCellDef ) fprintf( pFile, ".default_%s %s\n", SCL_INPUT_CELL, p->pInCellDef );
if ( p->tInArrDef != 0 ) fprintf( pFile, ".default_%s %.2f\n", SCL_INPUT_ARR, Scl_Wrd2Flt(p->tInArrDef) );
if ( p->tInSlewDef != 0 ) fprintf( pFile, ".default_%s %.2f\n", SCL_INPUT_SLEW, Scl_Wrd2Flt(p->tInSlewDef) );
if ( p->tInLoadDef != 0 ) fprintf( pFile, ".default_%s %.2f\n", SCL_INPUT_LOAD, Scl_Wrd2Flt(p->tInLoadDef) );
if ( p->tOutReqDef != 0 ) fprintf( pFile, ".default_%s %.2f\n", SCL_OUTPUT_REQ, Scl_Wrd2Flt(p->tOutReqDef) );
if ( p->tOutLoadDef != 0 ) fprintf( pFile, ".default_%s %.2f\n", SCL_OUTPUT_LOAD, Scl_Wrd2Flt(p->tOutLoadDef) );
Vec_PtrForEachEntry(char *, &p->vInCells, pName, i) if ( pName ) fprintf( pFile, ".%s %s %s\n", SCL_INPUT_CELL, Abc_NamStr(p->pNamI, i+1), pName );
Vec_WrdForEachEntry( &p->vInArrs, Value, i ) if ( Value != p->tInArrDef ) fprintf( pFile, ".%s %s %.2f\n", SCL_INPUT_ARR, Abc_NamStr(p->pNamI, i+1), Scl_Wrd2Flt(Value) );
Vec_WrdForEachEntry( &p->vInSlews, Value, i ) if ( Value != p->tInSlewDef ) fprintf( pFile, ".%s %s %.2f\n", SCL_INPUT_SLEW, Abc_NamStr(p->pNamI, i+1), Scl_Wrd2Flt(Value) );
Vec_WrdForEachEntry( &p->vInLoads, Value, i ) if ( Value != p->tInLoadDef ) fprintf( pFile, ".%s %s %.2f\n", SCL_INPUT_LOAD, Abc_NamStr(p->pNamI, i+1), Scl_Wrd2Flt(Value) );
Vec_WrdForEachEntry( &p->vOutReqs, Value, i ) if ( Value != p->tOutReqDef ) fprintf( pFile, ".%s %s %.2f\n", SCL_OUTPUT_REQ, Abc_NamStr(p->pNamO, i+1), Scl_Wrd2Flt(Value) );
Vec_WrdForEachEntry( &p->vOutLoads, Value, i ) if ( Value != p->tOutLoadDef ) fprintf( pFile, ".%s %s %.2f\n", SCL_OUTPUT_LOAD, Abc_NamStr(p->pNamO, i+1), Scl_Wrd2Flt(Value) );
if ( pFile != stdout )
fclose ( pFile );
}
/**Function*************************************************************
Synopsis [Internal APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Scl_ConHasInCells_( Scl_Con_t * p ) { return Vec_PtrCountZero(&p->vInCells) != Vec_PtrSize(&p->vInCells); }
static inline int Scl_ConHasInArrs_( Scl_Con_t * p ) { return Vec_WrdCountZero(&p->vInArrs) != Vec_WrdSize(&p->vInArrs); }
static inline int Scl_ConHasInSlews_( Scl_Con_t * p ) { return Vec_WrdCountZero(&p->vInSlews) != Vec_WrdSize(&p->vInSlews); }
static inline int Scl_ConHasInLoads_( Scl_Con_t * p ) { return Vec_WrdCountZero(&p->vInLoads) != Vec_WrdSize(&p->vInLoads); }
static inline int Scl_ConHasOutReqs_( Scl_Con_t * p ) { return Vec_WrdCountZero(&p->vOutReqs) != Vec_WrdSize(&p->vOutReqs); }
static inline int Scl_ConHasOutLoads_( Scl_Con_t * p ) { return Vec_WrdCountZero(&p->vOutLoads) != Vec_WrdSize(&p->vOutLoads); }
static inline char * Scl_ConGetInCell_( Scl_Con_t * p, int i ) { return Vec_PtrEntry( &p->vInCells, i ); }
static inline word Scl_ConGetInArr_( Scl_Con_t * p, int i ) { return Vec_WrdEntry( &p->vInArrs, i ); }
static inline word Scl_ConGetInSlew_( Scl_Con_t * p, int i ) { return Vec_WrdEntry( &p->vInSlews, i ); }
static inline word Scl_ConGetInLoad_( Scl_Con_t * p, int i ) { return Vec_WrdEntry( &p->vInLoads, i ); }
static inline word Scl_ConGetOutReq_( Scl_Con_t * p, int i ) { return Vec_WrdEntry( &p->vOutReqs, i ); }
static inline word Scl_ConGetOutLoad_( Scl_Con_t * p, int i ) { return Vec_WrdEntry( &p->vOutLoads, i ); }
/**Function*************************************************************
Synopsis [External APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
extern Scl_Con_t * Scl_ConReadMan();
static inline int Scl_ConIsRunning() { return Scl_ConReadMan() != NULL; }
static inline int Scl_ConHasInCells() { return Scl_ConHasInCells_ ( Scl_ConReadMan() ); }
static inline int Scl_ConHasInArrs() { return Scl_ConHasInArrs_ ( Scl_ConReadMan() ); }
static inline int Scl_ConHasInSlews() { return Scl_ConHasInSlews_ ( Scl_ConReadMan() ); }
static inline int Scl_ConHasInLoads() { return Scl_ConHasInLoads_ ( Scl_ConReadMan() ); }
static inline int Scl_ConHasOutReqs() { return Scl_ConHasOutReqs_ ( Scl_ConReadMan() ); }
static inline int Scl_ConHasOutLoads() { return Scl_ConHasOutLoads_( Scl_ConReadMan() ); }
static inline char * Scl_ConGetInCell( int i ) { return Scl_ConGetInCell_ ( Scl_ConReadMan(), i ); }
static inline word Scl_ConGetInArr( int i ) { return Scl_ConGetInArr_ ( Scl_ConReadMan(), i ); }
static inline word Scl_ConGetInSlew( int i ) { return Scl_ConGetInSlew_ ( Scl_ConReadMan(), i ); }
static inline word Scl_ConGetInLoad( int i ) { return Scl_ConGetInLoad_ ( Scl_ConReadMan(), i ); }
static inline word Scl_ConGetOutReq( int i ) { return Scl_ConGetOutReq_ ( Scl_ConReadMan(), i ); }
static inline word Scl_ConGetOutLoad( int i ) { return Scl_ConGetOutLoad_( Scl_ConReadMan(), i ); }
static inline float Scl_ConGetInArrFloat( int i ) { return Scl_Wrd2Flt( Scl_ConGetInArr(i) ); }
static inline float Scl_ConGetInSlewFloat( int i ) { return Scl_Wrd2Flt( Scl_ConGetInSlew(i) ); }
static inline float Scl_ConGetInLoadFloat( int i ) { return Scl_Wrd2Flt( Scl_ConGetInLoad(i) ); }
static inline float Scl_ConGetOutReqFloat( int i ) { return Scl_Wrd2Flt( Scl_ConGetOutReq(i) ); }
static inline float Scl_ConGetOutLoadFloat( int i ) { return Scl_Wrd2Flt( Scl_ConGetOutLoad(i) ); }
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_HEADER_END

9
src/map/scl/sclUtil.c
View File

@ -254,20 +254,21 @@ void Abc_SclReadTimingConstr( Abc_Frame_t * pAbc, char * pFileName, int fVerbose
pToken = strtok( Buffer, " \t\r\n" );
if ( pToken == NULL )
continue;
if ( !strcmp(pToken, "set_driving_cell") )
// if ( !strcmp(pToken, "set_driving_cell") )
if ( !strcmp(pToken, "default_input_cell") )
{
Abc_FrameSetDrivingCell( Abc_UtilStrsav(strtok(NULL, " \t\r\n")) );
if ( fVerbose )
printf( "Setting driving cell to be \"%s\".\n", Abc_FrameReadDrivingCell() );
}
else if ( !strcmp(pToken, "set_load") )
// else if ( !strcmp(pToken, "set_load") )
else if ( !strcmp(pToken, "default_output_load") )
{
Abc_FrameSetMaxLoad( atof(strtok(NULL, " \t\r\n")) );
if ( fVerbose )
printf( "Setting driving cell to be %f.\n", Abc_FrameReadMaxLoad() );
}
else
printf( "Unrecognized token \"%s\".\n", pToken );
// else printf( "Unrecognized token \"%s\".\n", pToken );
}
fclose( pFile );
}

12
src/misc/vec/vecPtr.h
View File

@ -232,6 +232,18 @@ static inline Vec_Ptr_t * Vec_PtrDupArray( Vec_Ptr_t * pVec )
SeeAlso []
***********************************************************************/
static inline void Vec_PtrZero( Vec_Ptr_t * p )
{
p->pArray = NULL;
p->nSize = 0;
p->nCap = 0;
}
static inline void Vec_PtrErase( Vec_Ptr_t * p )
{
ABC_FREE( p->pArray );
p->nSize = 0;
p->nCap = 0;
}
static inline void Vec_PtrFree( Vec_Ptr_t * p )
{
ABC_FREE( p->pArray );