mirror of https://github.com/YosysHQ/abc.git
Testing GIA with time manager.
This commit is contained in:
Alan Mishchenko
parent
f7caf84f21
commit
40d9b5853b
|
|
@ -451,6 +451,10 @@ SOURCE=.\src\base\abci\abcSymm.c
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\abci\abcTim.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\abci\abcTiming.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
|
|
|||
|
|
@ -315,7 +315,6 @@ void Aig_ObjPatchFanin0( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFaninNew
|
|||
***********************************************************************/
|
||||
void Aig_ObjPrint( Aig_Man_t * p, Aig_Obj_t * pObj )
|
||||
{
|
||||
int fHaig = 0;
|
||||
int fShowFanouts = 0;
|
||||
Aig_Obj_t * pTemp;
|
||||
if ( pObj == NULL )
|
||||
|
|
|
|||
|
|
@ -281,6 +281,7 @@ static inline int Gia_ManAndNum( Gia_Man_t * p ) { return p->nObjs
|
|||
static inline int Gia_ManCandNum( Gia_Man_t * p ) { return Gia_ManCiNum(p) + Gia_ManAndNum(p); }
|
||||
static inline int Gia_ManConstrNum( Gia_Man_t * p ) { return p->nConstrs; }
|
||||
static inline void Gia_ManFlipVerbose( Gia_Man_t * p ) { p->fVerbose ^= 1; }
|
||||
static inline int Gia_ManWithChoices( Gia_Man_t * p ) { return p->pReprs != NULL; }
|
||||
|
||||
static inline Gia_Obj_t * Gia_ManConst0( Gia_Man_t * p ) { return p->pObjs; }
|
||||
static inline Gia_Obj_t * Gia_ManConst1( Gia_Man_t * p ) { return Gia_Not(Gia_ManConst0(p)); }
|
||||
|
|
|
|||
|
|
@ -1266,7 +1266,7 @@ unsigned char * Gia_WriteEquivClasses( Gia_Man_t * p, int * pEquivSize )
|
|||
Gia_ClassForEachObj( p, iRepr, iNode )
|
||||
nItems++;
|
||||
}
|
||||
pBuffer = ABC_ALLOC( unsigned char, sizeof(int) * (nItems + 1) );
|
||||
pBuffer = ABC_ALLOC( unsigned char, sizeof(int) * (nItems + 10) );
|
||||
// write constant class
|
||||
iPos = Gia_WriteAigerEncode( pBuffer, 4, Abc_Var2Lit(0, 1) );
|
||||
//printf( "\nRepr = %d ", 0 );
|
||||
|
|
|
|||
|
|
@ -366,7 +366,7 @@ void Gia_ManReverseClasses( Gia_Man_t * p, int fNowIncreasing )
|
|||
Gia_ManForEachClass( p, iRepr )
|
||||
{
|
||||
Vec_IntPush( vCollected, iRepr );
|
||||
|
||||
/*
|
||||
// check classes
|
||||
if ( !fNowIncreasing )
|
||||
{
|
||||
|
|
@ -384,20 +384,8 @@ void Gia_ManReverseClasses( Gia_Man_t * p, int fNowIncreasing )
|
|||
iPrev = iNode;
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
iRepr = 129720;
|
||||
printf( "Class %d : ", iRepr );
|
||||
Gia_ClassForEachObj( p, iRepr, iNode )
|
||||
printf( " %d", iNode );
|
||||
printf( "\n" );
|
||||
|
||||
iRepr = 129737;
|
||||
printf( "Class %d : ", iRepr );
|
||||
Gia_ClassForEachObj( p, iRepr, iNode )
|
||||
printf( " %d", iNode );
|
||||
printf( "\n" );
|
||||
|
||||
// correct each class
|
||||
vClass = Vec_IntAlloc( 100 );
|
||||
Vec_IntForEachEntry( vCollected, iRepr, i )
|
||||
|
|
@ -408,14 +396,14 @@ void Gia_ManReverseClasses( Gia_Man_t * p, int fNowIncreasing )
|
|||
{
|
||||
if ( fNowIncreasing )
|
||||
assert( iRepr < iNode );
|
||||
else
|
||||
assert( iRepr > iNode );
|
||||
// else
|
||||
// assert( iRepr > iNode );
|
||||
Vec_IntPush( vClass, iNode );
|
||||
}
|
||||
// if ( !fNowIncreasing )
|
||||
// Vec_IntSort( vClass, 1 );
|
||||
if ( iRepr == 129720 || iRepr == 129737 )
|
||||
Vec_IntPrint( vClass );
|
||||
if ( !fNowIncreasing )
|
||||
Vec_IntSort( vClass, 1 );
|
||||
// if ( iRepr == 129720 || iRepr == 129737 )
|
||||
// Vec_IntPrint( vClass );
|
||||
// reverse the class
|
||||
iPrev = 0;
|
||||
iRepr = Vec_IntEntryLast( vClass );
|
||||
|
|
|
|||
|
|
@ -64,11 +64,12 @@ typedef enum {
|
|||
// the AIG node
|
||||
struct Hop_Obj_t_ // 6 words
|
||||
{
|
||||
void * pData; // misc
|
||||
union {
|
||||
union {
|
||||
void * pData; // misc
|
||||
int iData; }; // misc
|
||||
union {
|
||||
Hop_Obj_t * pNext; // strashing table
|
||||
int PioNum; // the number of PI/PO
|
||||
};
|
||||
int PioNum; }; // the number of PI/PO
|
||||
Hop_Obj_t * pFanin0; // fanin
|
||||
Hop_Obj_t * pFanin1; // fanin
|
||||
unsigned int Type : 3; // object type
|
||||
|
|
@ -182,8 +183,10 @@ static inline Hop_Obj_t * Hop_ObjFanin0( Hop_Obj_t * pObj ) { return Hop_R
|
|||
static inline Hop_Obj_t * Hop_ObjFanin1( Hop_Obj_t * pObj ) { return Hop_Regular(pObj->pFanin1); }
|
||||
static inline Hop_Obj_t * Hop_ObjChild0( Hop_Obj_t * pObj ) { return pObj->pFanin0; }
|
||||
static inline Hop_Obj_t * Hop_ObjChild1( Hop_Obj_t * pObj ) { return pObj->pFanin1; }
|
||||
static inline Hop_Obj_t * Hop_ObjChild0Copy( Hop_Obj_t * pObj ) { assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin0(pObj)? Hop_NotCond((Hop_Obj_t *)Hop_ObjFanin0(pObj)->pData, Hop_ObjFaninC0(pObj)) : NULL; }
|
||||
static inline Hop_Obj_t * Hop_ObjChild1Copy( Hop_Obj_t * pObj ) { assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin1(pObj)? Hop_NotCond((Hop_Obj_t *)Hop_ObjFanin1(pObj)->pData, Hop_ObjFaninC1(pObj)) : NULL; }
|
||||
static inline Hop_Obj_t * Hop_ObjChild0Copy( Hop_Obj_t * pObj ) { assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin0(pObj)? Hop_NotCond((Hop_Obj_t *)Hop_ObjFanin0(pObj)->pData, Hop_ObjFaninC0(pObj)) : NULL; }
|
||||
static inline Hop_Obj_t * Hop_ObjChild1Copy( Hop_Obj_t * pObj ) { assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin1(pObj)? Hop_NotCond((Hop_Obj_t *)Hop_ObjFanin1(pObj)->pData, Hop_ObjFaninC1(pObj)) : NULL; }
|
||||
static inline int Hop_ObjChild0CopyI( Hop_Obj_t * pObj ) { assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin0(pObj)? Abc_LitNotCond(Hop_ObjFanin0(pObj)->iData, Hop_ObjFaninC0(pObj)) : -1; }
|
||||
static inline int Hop_ObjChild1CopyI( Hop_Obj_t * pObj ) { assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin1(pObj)? Abc_LitNotCond(Hop_ObjFanin1(pObj)->iData, Hop_ObjFaninC1(pObj)) : -1; }
|
||||
static inline int Hop_ObjLevel( Hop_Obj_t * pObj ) { return pObj->nRefs; }
|
||||
static inline int Hop_ObjLevelNew( Hop_Obj_t * pObj ) { return 1 + Hop_ObjIsExor(pObj) + Abc_MaxInt(Hop_ObjFanin0(pObj)->nRefs, Hop_ObjFanin1(pObj)->nRefs); }
|
||||
static inline int Hop_ObjPhaseCompl( Hop_Obj_t * pObj ) { return Hop_IsComplement(pObj)? !Hop_Regular(pObj)->fPhase : pObj->fPhase; }
|
||||
|
|
|
|||
|
|
@ -9282,13 +9282,19 @@ int Abc_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
goto usage;
|
||||
}
|
||||
}
|
||||
/*
|
||||
|
||||
if ( pNtk == NULL )
|
||||
{
|
||||
Abc_Print( -1, "Empty network.\n" );
|
||||
return 1;
|
||||
}
|
||||
*/
|
||||
|
||||
if ( Abc_NtkIsStrash(pNtk) )
|
||||
{
|
||||
Abc_Print( -1, "This command works only for logic networks.\n" );
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
if ( Abc_NtkLatchNum(pNtk) == 0 )
|
||||
{
|
||||
|
|
@ -9296,13 +9302,7 @@ int Abc_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
return 1;
|
||||
}
|
||||
*/
|
||||
/*
|
||||
if ( !Abc_NtkIsStrash(pNtk) )
|
||||
{
|
||||
Abc_Print( -1, "Network should be strashed. Command has failed.\n" );
|
||||
return 1;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
if ( pNtk )
|
||||
{
|
||||
|
|
@ -9316,43 +9316,20 @@ int Abc_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
|
||||
}
|
||||
*/
|
||||
|
||||
{
|
||||
// extern void Abs_VfaManTest( Aig_Man_t * pAig, int nFrames, int nConfLimit, int fVerbose );
|
||||
extern void Aig_ManInterRepar( Aig_Man_t * pMan, int fVerbose );
|
||||
extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters );
|
||||
extern void Aig_ManSupportsTest( Aig_Man_t * pMan );
|
||||
extern int Aig_SupportSizeTest( Aig_Man_t * pMan );
|
||||
extern int Abc_NtkSuppSizeTest( Abc_Ntk_t * p );
|
||||
extern Aig_Man_t * Iso_ManTest( Aig_Man_t * pAig, int fVerbose );
|
||||
extern Abc_Ntk_t * Abc_NtkFromAigPhase( Aig_Man_t * pMan );
|
||||
extern Vec_Vec_t * Saig_IsoDetectFast( Aig_Man_t * pAig );
|
||||
extern Aig_Man_t * Abc_NtkToDarBmc( Abc_Ntk_t * pNtk, Vec_Int_t ** pvMap );
|
||||
extern void Abc2_NtkTestGia( char * pFileName, int fVerbose );
|
||||
extern void Saig_ManBmcTerSimTestPo( Aig_Man_t * p );
|
||||
extern int Abc_SclCheckNtk( Abc_Ntk_t * p );
|
||||
extern void Abc_SclPerformBuffering( Abc_Ntk_t * p, int Degree );
|
||||
|
||||
/*
|
||||
if ( pNtk )
|
||||
{
|
||||
/*
|
||||
Aig_Man_t * pAig = Abc_NtkToDar( pNtk, 0, 1 );
|
||||
Saig_ManBmcTerSimTestPo( pAig );
|
||||
Aig_ManStop( pAig );
|
||||
*/
|
||||
Abc_SclPerformBuffering( pNtk, nDecMax );
|
||||
/*
|
||||
extern Abc_Ntk_t * Abc_NtkShareXor( Abc_Ntk_t * pNtk );
|
||||
Abc_Ntk_t * pNtkRes = Abc_NtkShareXor( pNtk );
|
||||
if ( pNtkRes == NULL )
|
||||
printf( "Transformation has failed.\n" );
|
||||
else
|
||||
Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
|
||||
*/
|
||||
}
|
||||
*/
|
||||
|
||||
// Abc2_NtkTestGia( "", 1 );
|
||||
}
|
||||
if ( pNtk )
|
||||
{
|
||||
extern void Abc_NtkTestTim( Abc_Ntk_t * pNtk, int fVerbose );
|
||||
Abc_NtkTestTim( pNtk, fVerbose );
|
||||
}
|
||||
|
||||
return 0;
|
||||
usage:
|
||||
|
|
|
|||
|
|
@ -0,0 +1,416 @@
|
|||
/**CFile****************************************************************
|
||||
|
||||
FileName [abcTim.c]
|
||||
|
||||
SystemName [ABC: Logic synthesis and verification system.]
|
||||
|
||||
PackageName [Network and node package.]
|
||||
|
||||
Synopsis [Testing hierarchy/timing manager.]
|
||||
|
||||
Author [Alan Mishchenko]
|
||||
|
||||
Affiliation [UC Berkeley]
|
||||
|
||||
Date [Ver. 1.0. Started - June 20, 2005.]
|
||||
|
||||
Revision [$Id: abcTim.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
|
||||
|
||||
***********************************************************************/
|
||||
|
||||
#include "base/abc/abc.h"
|
||||
#include "aig/gia/giaAig.h"
|
||||
#include "misc/tim/tim.h"
|
||||
#include "opt/dar/dar.h"
|
||||
#include "proof/dch/dch.h"
|
||||
|
||||
ABC_NAMESPACE_IMPL_START
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// DECLARATIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define TIM_TEST_BOX_RATIO 30
|
||||
|
||||
// assume that every TIM_TEST_BOX_RATIO'th object is a white box
|
||||
static inline int Abc_NodeIsWhiteBox( Abc_Obj_t * pObj ) { assert( Abc_ObjIsNode(pObj) ); return Abc_ObjId(pObj) % TIM_TEST_BOX_RATIO == 0; }
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// FUNCTION DEFINITIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Derives one delay table.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
float * Abc_NtkTestTimDelayTableOne( int nInputs, int nOutputs )
|
||||
{
|
||||
float * pTable;
|
||||
int i, k;
|
||||
pTable = ABC_ALLOC( float, 3 + nInputs * nOutputs );
|
||||
pTable[0] = (float)-1;
|
||||
pTable[1] = (float)nInputs;
|
||||
pTable[2] = (float)nOutputs;
|
||||
for ( i = 0; i < nOutputs; i++ )
|
||||
for ( k = 0; k < nInputs; k++ )
|
||||
pTable[3 + i * nInputs + k] = 1.0;
|
||||
return pTable;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Derives timing tables for each fanin size.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Vec_Ptr_t * Abc_NtkTestTimDelayTables( int nFaninsMax )
|
||||
{
|
||||
Vec_Ptr_t * vTables;
|
||||
float * pTable;
|
||||
int i;
|
||||
vTables = Vec_PtrAlloc( nFaninsMax + 1 );
|
||||
for ( i = 0; i <= nFaninsMax; i++ )
|
||||
{
|
||||
// derive delay table
|
||||
pTable = Abc_NtkTestTimDelayTableOne( i, 1 );
|
||||
// set its table ID
|
||||
pTable[0] = (float)Vec_PtrSize(vTables);
|
||||
// save in the resulting array
|
||||
Vec_PtrPush( vTables, pTable );
|
||||
}
|
||||
return vTables;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Derives GIA for the output of the local function of one node.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Abc_NtkTestTimNodeStrash_rec( Gia_Man_t * pGia, Hop_Obj_t * pObj )
|
||||
{
|
||||
assert( !Hop_IsComplement(pObj) );
|
||||
if ( !Hop_ObjIsNode(pObj) || Hop_ObjIsMarkA(pObj) )
|
||||
return;
|
||||
Abc_NtkTestTimNodeStrash_rec( pGia, Hop_ObjFanin0(pObj) );
|
||||
Abc_NtkTestTimNodeStrash_rec( pGia, Hop_ObjFanin1(pObj) );
|
||||
pObj->iData = Gia_ManHashAnd( pGia, Hop_ObjChild0CopyI(pObj), Hop_ObjChild1CopyI(pObj) );
|
||||
assert( !Hop_ObjIsMarkA(pObj) ); // loop detection
|
||||
Hop_ObjSetMarkA( pObj );
|
||||
}
|
||||
int Abc_NtkTestTimNodeStrash( Gia_Man_t * pGia, Abc_Obj_t * pNode )
|
||||
{
|
||||
Hop_Man_t * pMan;
|
||||
Hop_Obj_t * pRoot;
|
||||
Abc_Obj_t * pFanin;
|
||||
int i;
|
||||
assert( Abc_ObjIsNode(pNode) );
|
||||
assert( Abc_NtkIsAigLogic(pNode->pNtk) );
|
||||
// get the local AIG manager and the local root node
|
||||
pMan = (Hop_Man_t *)pNode->pNtk->pManFunc;
|
||||
pRoot = (Hop_Obj_t *)pNode->pData;
|
||||
// check the constant case
|
||||
if ( Abc_NodeIsConst(pNode) || Hop_Regular(pRoot) == Hop_ManConst1(pMan) )
|
||||
return !Hop_IsComplement(pRoot);
|
||||
// set elementary variables
|
||||
Abc_ObjForEachFanin( pNode, pFanin, i )
|
||||
Hop_IthVar(pMan, i)->iData = pFanin->iTemp;
|
||||
// strash the AIG of this node
|
||||
Abc_NtkTestTimNodeStrash_rec( pGia, Hop_Regular(pRoot) );
|
||||
Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
|
||||
// return the final node with complement if needed
|
||||
return Abc_LitNotCond( Hop_Regular(pRoot)->iData, Hop_IsComplement(pRoot) );
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Collect nodes reachable from this box.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Abc_NtkTestTimCollectCone_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vNodes )
|
||||
{
|
||||
Abc_Obj_t * pFanin;
|
||||
int i;
|
||||
if ( Abc_NodeIsTravIdCurrent( pObj ) )
|
||||
return;
|
||||
Abc_NodeSetTravIdCurrent( pObj );
|
||||
if ( Abc_ObjIsCi(pObj) )
|
||||
return;
|
||||
assert( Abc_ObjIsNode( pObj ) );
|
||||
Abc_ObjForEachFanin( pObj, pFanin, i )
|
||||
Abc_NtkTestTimCollectCone_rec( pFanin, vNodes );
|
||||
Vec_PtrPush( vNodes, pObj );
|
||||
}
|
||||
Vec_Ptr_t * Abc_NtkTestTimCollectCone( Abc_Ntk_t * pNtk, Abc_Obj_t * pObj )
|
||||
{
|
||||
Vec_Ptr_t * vCone = Vec_PtrAlloc( 1000 );
|
||||
if ( pObj != NULL )
|
||||
{
|
||||
// collect for one node
|
||||
assert( Abc_ObjIsNode(pObj) );
|
||||
assert( !Abc_NodeIsTravIdCurrent( pObj ) );
|
||||
Abc_NtkTestTimCollectCone_rec( pObj, vCone );
|
||||
// remove the node because it is a white box
|
||||
Vec_PtrPop( vCone );
|
||||
}
|
||||
else
|
||||
{
|
||||
// collect for all COs
|
||||
Abc_Obj_t * pObj;
|
||||
int i;
|
||||
Abc_NtkForEachCo( pNtk, pObj, i )
|
||||
Abc_NtkTestTimCollectCone_rec( Abc_ObjFanin0(pObj), vCone );
|
||||
}
|
||||
return vCone;
|
||||
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Derives GIA manager together with the hierachy manager.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Gia_Man_t * Abc_NtkTestTimDeriveGia( Abc_Ntk_t * pNtk, int fVerbose )
|
||||
{
|
||||
Gia_Man_t * pTemp;
|
||||
Gia_Man_t * pGia = NULL;
|
||||
Tim_Man_t * pTim = NULL;
|
||||
Vec_Ptr_t * vNodes, * vCone;
|
||||
Abc_Obj_t * pObj, * pFanin;
|
||||
int i, k, curPi, curPo, TableID;
|
||||
|
||||
// compute topological order
|
||||
vNodes = Abc_NtkDfs( pNtk, 0 );
|
||||
|
||||
// construct GIA
|
||||
Abc_NtkCleanCopy( pNtk );
|
||||
pGia = Gia_ManStart( Abc_NtkObjNumMax(pNtk) );
|
||||
Gia_ManHashAlloc( pGia );
|
||||
// create primary inputs
|
||||
Abc_NtkForEachCi( pNtk, pObj, i )
|
||||
pObj->iTemp = Gia_ManAppendCi(pGia);
|
||||
// create internal nodes in a topologic order from white boxes
|
||||
Abc_NtkIncrementTravId( pNtk );
|
||||
Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
|
||||
{
|
||||
if ( !Abc_NodeIsWhiteBox(pObj) )
|
||||
continue;
|
||||
// collect nodes in the DFS order from this box
|
||||
vCone = Abc_NtkTestTimCollectCone( pNtk, pObj );
|
||||
// perform GIA constructino for these nodes
|
||||
Vec_PtrForEachEntry( Abc_Obj_t *, vCone, pFanin, k )
|
||||
pFanin->iTemp = Abc_NtkTestTimNodeStrash( pGia, pFanin );
|
||||
// create inputs of the box
|
||||
Abc_ObjForEachFanin( pObj, pFanin, k )
|
||||
Gia_ManAppendCo( pGia, pFanin->iTemp );
|
||||
// craete outputs of the box
|
||||
pObj->iTemp = Gia_ManAppendCi(pGia);
|
||||
if ( fVerbose )
|
||||
printf( "White box %7d : Cone = %7d Lit = %7d.\n", Abc_ObjId(pObj), Vec_PtrSize(vCone), pObj->iTemp );
|
||||
Vec_PtrFree( vCone );
|
||||
}
|
||||
// collect node in the DSF from the primary outputs
|
||||
vCone = Abc_NtkTestTimCollectCone( pNtk, NULL );
|
||||
// perform GIA constructino for these nodes
|
||||
Vec_PtrForEachEntry( Abc_Obj_t *, vCone, pFanin, k )
|
||||
pObj->iTemp = Abc_NtkTestTimNodeStrash( pGia, pFanin );
|
||||
Vec_PtrFree( vCone );
|
||||
// create primary outputs
|
||||
Abc_NtkForEachCo( pNtk, pObj, i )
|
||||
pObj->iTemp = Gia_ManAppendCo( pGia, Abc_ObjFanin0(pObj)->iTemp );
|
||||
// finalize GIA
|
||||
Gia_ManHashStop( pGia );
|
||||
Gia_ManSetRegNum( pGia, 0 );
|
||||
// clean up GIA
|
||||
pGia = Gia_ManCleanup( pTemp = pGia );
|
||||
Gia_ManStop( pTemp );
|
||||
//Gia_ManPrint( pGia );
|
||||
|
||||
// construct the timing manager
|
||||
pTim = Tim_ManStart( Gia_ManPiNum(pGia), Gia_ManPoNum(pGia) );
|
||||
Tim_ManSetDelayTables( pTim, Abc_NtkTestTimDelayTables(Abc_NtkGetFaninMax(pNtk)) );
|
||||
// create timing boxes
|
||||
curPi = Abc_NtkPiNum( pNtk );
|
||||
curPo = 0;
|
||||
Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
|
||||
{
|
||||
if ( !Abc_NodeIsWhiteBox(pObj) )
|
||||
continue;
|
||||
TableID = Abc_ObjFaninNum(pObj); // in this case, the node size is the ID of its delay table
|
||||
Tim_ManCreateBox( pTim, curPo, Abc_ObjFaninNum(pObj), curPi, 1, TableID );
|
||||
curPi += 1;
|
||||
curPo += Abc_ObjFaninNum(pObj);
|
||||
}
|
||||
curPo += Abc_NtkPoNum( pNtk );
|
||||
assert( curPi == Gia_ManPiNum(pGia) );
|
||||
assert( curPo == Gia_ManPoNum(pGia) );
|
||||
Vec_PtrFree( vNodes );
|
||||
|
||||
// attach the timing manager
|
||||
assert( pGia->pManTime == NULL );
|
||||
pGia->pManTime = pTim;
|
||||
// return
|
||||
return pGia;
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Performs synthesis with or without structural choices.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Gia_Man_t * Abc_NtkTestTimPerformSynthesis( Gia_Man_t * p, int fChoices )
|
||||
{
|
||||
Gia_Man_t * pGia;
|
||||
Aig_Man_t * pNew, * pTemp;
|
||||
Dch_Pars_t Pars, * pPars = &Pars;
|
||||
Dch_ManSetDefaultParams( pPars );
|
||||
pNew = Gia_ManToAig( p, 0 );
|
||||
if ( fChoices )
|
||||
pNew = Dar_ManChoiceNew( pNew, pPars );
|
||||
else
|
||||
{
|
||||
pNew = Dar_ManCompress2( pTemp = pNew, 1, 1, 1, 0, 0 );
|
||||
Aig_ManStop( pTemp );
|
||||
}
|
||||
pGia = Gia_ManFromAig( pNew );
|
||||
Aig_ManStop( pNew );
|
||||
return pGia;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Tests the hierarchy-timing manager.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Abc_NtkTestTimByWritingFile( Gia_Man_t * pGia, char * pFileName )
|
||||
{
|
||||
Gia_Man_t * pGia2;
|
||||
|
||||
// normalize choices
|
||||
if ( Gia_ManWithChoices(pGia) )
|
||||
{
|
||||
Gia_ManVerifyChoices( pGia );
|
||||
Gia_ManReverseClasses( pGia, 0 );
|
||||
}
|
||||
// write file
|
||||
Gia_WriteAiger( pGia, pFileName, 0, 0 );
|
||||
// unnormalize choices
|
||||
if ( Gia_ManWithChoices(pGia) )
|
||||
Gia_ManReverseClasses( pGia, 1 );
|
||||
|
||||
// read file
|
||||
pGia2 = Gia_ReadAiger( pFileName, 1, 1 );
|
||||
|
||||
// normalize choices
|
||||
if ( Gia_ManWithChoices(pGia2) )
|
||||
{
|
||||
Gia_ManVerifyChoices( pGia2 );
|
||||
Gia_ManReverseClasses( pGia2, 1 );
|
||||
}
|
||||
|
||||
// compare resulting managers
|
||||
if ( Gia_ManCompare( pGia, pGia2 ) )
|
||||
printf( "Verification suceessful.\n" );
|
||||
|
||||
Gia_ManStop( pGia2 );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Tests construction and serialization.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Abc_NtkTestTim( Abc_Ntk_t * pNtk, int fVerbose )
|
||||
{
|
||||
int fUseChoices = 1;
|
||||
Gia_Man_t * pGia, * pTemp;
|
||||
|
||||
// this test only works for a logic network (for example, network with LUT mapping)
|
||||
assert( Abc_NtkIsLogic(pNtk) );
|
||||
// make sure local functions of the nodes are in the AIG form
|
||||
Abc_NtkToAig( pNtk );
|
||||
|
||||
// create GIA manager (pGia) with hierarhy/timing manager attached (pGia->pManTime)
|
||||
// while assuming that some nodes are white boxes (see Abc_NodeIsWhiteBox)
|
||||
pGia = Abc_NtkTestTimDeriveGia( pNtk, fVerbose );
|
||||
printf( "Created GIA manager for network with %d white boxes.\n", Tim_ManBoxNum(pGia->pManTime) );
|
||||
|
||||
// print the timing manager
|
||||
if ( fVerbose )
|
||||
Tim_ManPrint( pGia->pManTime );
|
||||
|
||||
// test writing both managers into a file and reading them back
|
||||
Abc_NtkTestTimByWritingFile( pGia, "test1.aig" );
|
||||
|
||||
// perform synthesis
|
||||
pGia = Abc_NtkTestTimPerformSynthesis( pTemp = pGia, fUseChoices );
|
||||
Gia_ManStop( pTemp );
|
||||
|
||||
// test writing both managers into a file and reading them back
|
||||
Abc_NtkTestTimByWritingFile( pGia, "test2.aig" );
|
||||
|
||||
Gia_ManStop( pGia );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
ABC_NAMESPACE_IMPL_END
|
||||
|
||||
|
|
@ -62,6 +62,7 @@ SRC += src/base/abci/abc.c \
|
|||
src/base/abci/abcStrash.c \
|
||||
src/base/abci/abcSweep.c \
|
||||
src/base/abci/abcSymm.c \
|
||||
src/base/abci/abcTim.c \
|
||||
src/base/abci/abcTiming.c \
|
||||
src/base/abci/abcUnate.c \
|
||||
src/base/abci/abcUnreach.c \
|
||||
|
|
|
|||
|
|
@ -64,7 +64,10 @@ extern int Tim_ManBoxInputFirst( Tim_Man_t * p, int iBox );
|
|||
extern int Tim_ManBoxOutputFirst( Tim_Man_t * p, int iBox );
|
||||
extern int Tim_ManBoxInputNum( Tim_Man_t * p, int iBox );
|
||||
extern int Tim_ManBoxOutputNum( Tim_Man_t * p, int iBox );
|
||||
extern int Tim_ManBoxDelayTableId( Tim_Man_t * p, int iBox );
|
||||
extern float * Tim_ManBoxDelayTable( Tim_Man_t * p, int iBox );
|
||||
extern int Tim_ManBoxCopy( Tim_Man_t * p, int iBox );
|
||||
extern void Tim_ManBoxSetCopy( Tim_Man_t * p, int iBox, int iCopy );
|
||||
/*=== timDump.c ===========================================================*/
|
||||
extern Vec_Str_t * Tim_ManSave( Tim_Man_t * p );
|
||||
extern Tim_Man_t * Tim_ManLoad( Vec_Str_t * p );
|
||||
|
|
|
|||
|
|
@ -121,13 +121,12 @@ int Tim_ManBoxForCo( Tim_Man_t * p, int iCo )
|
|||
***********************************************************************/
|
||||
int Tim_ManBoxInputFirst( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
Tim_Box_t * pBox = (Tim_Box_t *)Vec_PtrEntry( p->vBoxes, iBox );
|
||||
return pBox->Inouts[0];
|
||||
return Tim_ManBox(p, iBox)->Inouts[0];
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Returns the first input of the box.]
|
||||
Synopsis [Returns the first output of the box.]
|
||||
|
||||
Description []
|
||||
|
||||
|
|
@ -138,13 +137,12 @@ int Tim_ManBoxInputFirst( Tim_Man_t * p, int iBox )
|
|||
***********************************************************************/
|
||||
int Tim_ManBoxOutputFirst( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
Tim_Box_t * pBox = (Tim_Box_t *)Vec_PtrEntry( p->vBoxes, iBox );
|
||||
return pBox->Inouts[pBox->nInputs];
|
||||
return Tim_ManBox(p, iBox)->Inouts[Tim_ManBox(p, iBox)->nInputs];
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Returns the first input of the box.]
|
||||
Synopsis [Returns the number of box inputs.]
|
||||
|
||||
Description []
|
||||
|
||||
|
|
@ -155,13 +153,12 @@ int Tim_ManBoxOutputFirst( Tim_Man_t * p, int iBox )
|
|||
***********************************************************************/
|
||||
int Tim_ManBoxInputNum( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
Tim_Box_t * pBox = (Tim_Box_t *)Vec_PtrEntry( p->vBoxes, iBox );
|
||||
return pBox->nInputs;
|
||||
return Tim_ManBox(p, iBox)->nInputs;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Returns the first input of the box.]
|
||||
Synopsis [Returns the number of box outputs.]
|
||||
|
||||
Description []
|
||||
|
||||
|
|
@ -172,13 +169,28 @@ int Tim_ManBoxInputNum( Tim_Man_t * p, int iBox )
|
|||
***********************************************************************/
|
||||
int Tim_ManBoxOutputNum( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
Tim_Box_t * pBox = (Tim_Box_t *)Vec_PtrEntry( p->vBoxes, iBox );
|
||||
return pBox->nOutputs;
|
||||
return Tim_ManBox(p, iBox)->nOutputs;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
Synopsis [Return the delay table id.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Tim_ManBoxDelayTableId( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
return Tim_ManBox(p, iBox)->iDelayTable;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Return the delay table.]
|
||||
|
||||
Description []
|
||||
|
||||
|
|
@ -190,7 +202,7 @@ int Tim_ManBoxOutputNum( Tim_Man_t * p, int iBox )
|
|||
float * Tim_ManBoxDelayTable( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
float * pTable;
|
||||
Tim_Box_t * pBox = (Tim_Box_t *)Vec_PtrEntry( p->vBoxes, iBox );
|
||||
Tim_Box_t * pBox = Tim_ManBox(p, iBox);
|
||||
if ( pBox->iDelayTable < 0 )
|
||||
return NULL;
|
||||
pTable = (float *)Vec_PtrEntry( p->vDelayTables, pBox->iDelayTable );
|
||||
|
|
@ -199,6 +211,39 @@ float * Tim_ManBoxDelayTable( Tim_Man_t * p, int iBox )
|
|||
return pTable;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Returns the copy of the box.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Tim_ManBoxCopy( Tim_Man_t * p, int iBox )
|
||||
{
|
||||
return Tim_ManBox(p, iBox)->iCopy;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Sets the copy of the box.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Tim_ManBoxSetCopy( Tim_Man_t * p, int iBox, int iCopy )
|
||||
{
|
||||
Tim_ManBox(p, iBox)->iCopy = iCopy;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -62,13 +62,14 @@ Vec_Str_t * Tim_ManSave( Tim_Man_t * p )
|
|||
Vec_StrPutI_ne( vStr, Tim_ManPoNum(p) );
|
||||
// save number of boxes
|
||||
Vec_StrPutI_ne( vStr, Tim_ManBoxNum(p) );
|
||||
// for each box, save num_inputs, num_outputs, and delay table ID
|
||||
// for each box, save num_inputs, num_outputs, delay table ID, and copy field
|
||||
if ( Tim_ManBoxNum(p) > 0 )
|
||||
Tim_ManForEachBox( p, pBox, i )
|
||||
{
|
||||
Vec_StrPutI_ne( vStr, Tim_ManBoxInputNum(p, pBox->iBox) );
|
||||
Vec_StrPutI_ne( vStr, Tim_ManBoxOutputNum(p, pBox->iBox) );
|
||||
Vec_StrPutI_ne( vStr, pBox->iDelayTable ); // can be -1 if delay table is not given
|
||||
Vec_StrPutI_ne( vStr, Tim_ManBoxDelayTableId(p, pBox->iBox) ); // can be -1 if delay table is not given
|
||||
Vec_StrPutI_ne( vStr, Tim_ManBoxCopy(p, pBox->iBox) ); // can be -1 if the copy is node defined
|
||||
}
|
||||
// save the number of delay tables
|
||||
Vec_StrPutI_ne( vStr, Tim_ManDelayTableNum(p) );
|
||||
|
|
@ -110,7 +111,7 @@ Tim_Man_t * Tim_ManLoad( Vec_Str_t * p )
|
|||
{
|
||||
Tim_Man_t * pMan;
|
||||
int VerNum, nCis, nCos, nPis, nPos;
|
||||
int nBoxes, nBoxIns, nBoxOuts;
|
||||
int nBoxes, nBoxIns, nBoxOuts, CopyBox;
|
||||
int TableId, nTables, TableSize, TableX, TableY;
|
||||
int i, k, curPi, curPo, iStr = 0;
|
||||
float * pDelayTable;
|
||||
|
|
@ -138,7 +139,9 @@ Tim_Man_t * Tim_ManLoad( Vec_Str_t * p )
|
|||
nBoxIns = Vec_StrGetI_ne( p, &iStr );
|
||||
nBoxOuts = Vec_StrGetI_ne( p, &iStr );
|
||||
TableId = Vec_StrGetI_ne( p, &iStr );
|
||||
CopyBox = Vec_StrGetI_ne( p, &iStr );
|
||||
Tim_ManCreateBox( pMan, curPo, nBoxIns, curPi, nBoxOuts, TableId );
|
||||
Tim_ManBoxSetCopy( pMan, i, CopyBox );
|
||||
curPi += nBoxOuts;
|
||||
curPo += nBoxIns;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,6 +70,7 @@ struct Tim_Box_t_
|
|||
int nInputs; // the number of box inputs (POs)
|
||||
int nOutputs; // the number of box outputs (PIs)
|
||||
int iDelayTable; // index of the delay table
|
||||
int iCopy; // copy of this box
|
||||
int Inouts[0]; // the int numbers of PIs and POs
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -186,7 +186,9 @@ void Tim_ManPrint( Tim_Man_t * p )
|
|||
Tim_Obj_t * pObj, * pPrev;
|
||||
float * pTable;
|
||||
int i, j, k, TableX, TableY;
|
||||
printf( "TIMING INFORMATION:\n" );
|
||||
if ( p == NULL )
|
||||
return;
|
||||
printf( "TIMING MANAGER:\n" );
|
||||
|
||||
// print CI info
|
||||
pPrev = p->pCis;
|
||||
|
|
@ -214,7 +216,10 @@ void Tim_ManPrint( Tim_Man_t * p )
|
|||
if ( Tim_ManBoxNum(p) > 0 )
|
||||
Tim_ManForEachBox( p, pBox, i )
|
||||
{
|
||||
printf( "*** Box %5d : Ins = %4d. Outs = %4d. DelayTable = %4d\n", i, pBox->nInputs, pBox->nOutputs, pBox->iDelayTable );
|
||||
printf( "*** Box %5d : I =%4d. O =%4d. I1 =%6d. O1 =%6d. Table =%4d\n",
|
||||
i, pBox->nInputs, pBox->nOutputs,
|
||||
Tim_ManBoxInputFirst(p, i), Tim_ManBoxOutputFirst(p, i),
|
||||
pBox->iDelayTable );
|
||||
|
||||
// print box inputs
|
||||
pPrev = Tim_ManBoxInput( p, pBox, 0 );
|
||||
|
|
|
|||
Loading…
Reference in New Issue