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

Various changes.

This commit is contained in:
Alan Mishchenko 2021-09-02 22:54:19 -07:00
parent 388255e557
commit a718318740
16 changed files with 539 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/aig/gia/gia.h
View File

@ -171,6 +171,7 @@ struct Gia_Man_t_
Vec_Int_t * vCoReqs; // CO required times
Vec_Int_t * vCoArrs; // CO arrival times
Vec_Int_t * vCoAttrs; // CO attributes
Vec_Int_t * vWeights; // object attributes
int And2Delay; // delay of the AND gate
float DefInArrs; // default PI arrival times
float DefOutReqs; // default PO required times
@ -179,6 +180,7 @@ struct Gia_Man_t_
int nTravIdsAlloc; // the number of trav IDs allocated
Vec_Ptr_t * vNamesIn; // the input names
Vec_Ptr_t * vNamesOut; // the output names
Vec_Ptr_t * vNamesNode; // the node names
Vec_Int_t * vUserPiIds; // numbers assigned to PIs by the user
Vec_Int_t * vUserPoIds; // numbers assigned to POs by the user
Vec_Int_t * vUserFfIds; // numbers assigned to FFs by the user
@ -480,6 +482,8 @@ static inline void Gia_ObjSetValue( Gia_Obj_t * pObj, int i ) {
static inline int Gia_ObjPhase( Gia_Obj_t * pObj ) { return pObj->fPhase; }
static inline int Gia_ObjPhaseReal( Gia_Obj_t * pObj ) { return Gia_Regular(pObj)->fPhase ^ Gia_IsComplement(pObj); }
static inline int Gia_ObjPhaseDiff( Gia_Man_t * p, int i, int k ) { return Gia_ManObj(p, i)->fPhase ^ Gia_ManObj(p, k)->fPhase; }
static inline char * Gia_ObjName( Gia_Man_t * p, int i ) { return p->vNamesNode ? (char*)Vec_PtrEntry(p->vNamesNode, i) : NULL; }
static inline char * Gia_ObjNameObj( Gia_Man_t * p, Gia_Obj_t * pObj ) { return p->vNamesNode ? (char*)Vec_PtrEntry(p->vNamesNode, Gia_ObjId(p, pObj)) : NULL; }
static inline int Gia_ObjIsTerm( Gia_Obj_t * pObj ) { return pObj->fTerm; }
static inline int Gia_ObjIsAndOrConst0( Gia_Obj_t * pObj ) { return!pObj->fTerm; }
@ -618,6 +622,8 @@ static inline void Gia_ObjSetTravIdCurrentId( Gia_Man_t * p, int Id )
static inline void Gia_ObjSetTravIdPreviousId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); p->pTravIds[Id] = p->nTravIds - 1; }
static inline int Gia_ObjIsTravIdCurrentId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); return (p->pTravIds[Id] == p->nTravIds); }
static inline int Gia_ObjIsTravIdPreviousId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); return (p->pTravIds[Id] == p->nTravIds - 1); }
static inline int Gia_ObjUpdateTravIdCurrentId( Gia_Man_t * p, int Id ) { if ( Gia_ObjIsTravIdCurrentId(p, Id) ) return 1; Gia_ObjSetTravIdCurrentId(p, Id); return 0; }
static inline int Gia_ObjUpdateTravIdPreviousId( Gia_Man_t * p, int Id ) { if ( Gia_ObjIsTravIdPreviousId(p, Id) ) return 1; Gia_ObjSetTravIdPreviousId(p, Id); return 0; }
static inline void Gia_ManTimeClean( Gia_Man_t * p ) { int i; assert( p->vTiming != NULL ); Vec_FltFill(p->vTiming, 3*Gia_ManObjNum(p), 0); for ( i = 0; i < Gia_ManObjNum(p); i++ ) Vec_FltWriteEntry( p->vTiming, 3*i+1, (float)(ABC_INFINITY) ); }
static inline void Gia_ManTimeStart( Gia_Man_t * p ) { assert( p->vTiming == NULL ); p->vTiming = Vec_FltAlloc(0); Gia_ManTimeClean( p ); }
@ -1305,6 +1311,7 @@ extern Gia_Man_t * Gia_ManDupMarked( Gia_Man_t * p );
extern Gia_Man_t * Gia_ManDupTimes( Gia_Man_t * p, int nTimes );
extern Gia_Man_t * Gia_ManDupDfs( Gia_Man_t * p );
extern Gia_Man_t * Gia_ManDupDfsOnePo( Gia_Man_t * p, int iPo );
extern Gia_Man_t * Gia_ManDupDfsRehash( Gia_Man_t * p );
extern Gia_Man_t * Gia_ManDupCofactorVar( Gia_Man_t * p, int iVar, int Value );
extern Gia_Man_t * Gia_ManDupCofactorObj( Gia_Man_t * p, int iObj, int Value );
extern Gia_Man_t * Gia_ManDupMux( int iVar, Gia_Man_t * pCof1, Gia_Man_t * pCof0 );
@ -1567,6 +1574,7 @@ extern int Gia_ManIncrSimCheckOver( Gia_Man_t * p, int iLit0, in
extern int Gia_ManIncrSimCheckEqual( Gia_Man_t * p, int iLit0, int iLit1 );
/*=== giaSimBase.c ============================================================*/
extern Vec_Wrd_t * Gia_ManSimPatSim( Gia_Man_t * p );
extern Vec_Wrd_t * Gia_ManSimPatSimOut( Gia_Man_t * pGia, Vec_Wrd_t * vSimsPi, int fOuts );
/*=== giaSpeedup.c ============================================================*/
extern float Gia_ManDelayTraceLut( Gia_Man_t * p );
extern float Gia_ManDelayTraceLutPrint( Gia_Man_t * p, int fVerbose );

31
src/aig/gia/giaAiger.c
View File

@ -176,7 +176,7 @@ Vec_Str_t * Gia_AigerWriteLiterals( Vec_Int_t * vLits )
Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSimple, int fSkipStrash, int fCheck )
{
Gia_Man_t * pNew, * pTemp;
Vec_Ptr_t * vNamesIn = NULL, * vNamesOut = NULL, * vNamesRegIn = NULL, * vNamesRegOut = NULL;
Vec_Ptr_t * vNamesIn = NULL, * vNamesOut = NULL, * vNamesRegIn = NULL, * vNamesRegOut = NULL, * vNamesNode = NULL;
Vec_Int_t * vLits = NULL, * vPoTypes = NULL;
Vec_Int_t * vNodes, * vDrivers, * vInits = NULL;
int iObj, iNode0, iNode1, fHieOnly = 0;
@ -388,7 +388,7 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
char * pType = (char *)pCur;
char * pName = NULL;
// check terminal type
if ( *pCur != 'i' && *pCur != 'o' && *pCur != 'l' )
if ( *pCur != 'i' && *pCur != 'o' && *pCur != 'l' && *pCur != 'n' )
{
fError = 1;
break;
@ -442,6 +442,18 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
Vec_PtrPush( vNamesRegIn, Abc_UtilStrsav(Buffer) );
Vec_PtrPush( vNamesRegOut, Abc_UtilStrsav(pName) );
}
else if ( *pType == 'n' )
{
if ( Vec_IntSize(&pNew->vHTable) != 0 )
{
printf( "Structural hashing should be disabled to read internal nodes names.\n" );
fError = 1;
break;
}
if ( vNamesNode == NULL )
vNamesNode = Vec_PtrStart( Gia_ManObjNum(pNew) );
Vec_PtrWriteEntry( vNamesNode, iTerm, Abc_UtilStrsav(pName) );
}
else
{
fError = 1;
@ -451,11 +463,12 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
}
if ( fError )
{
printf( "Error occurred when reading signal names.\n" );
printf( "Error occurred when reading signal names. Signal names ignored.\n" );
if ( vNamesIn ) Vec_PtrFreeFree( vNamesIn ), vNamesIn = NULL;
if ( vNamesOut ) Vec_PtrFreeFree( vNamesOut ), vNamesOut = NULL;
if ( vNamesRegIn ) Vec_PtrFreeFree( vNamesRegIn ), vNamesRegIn = NULL;
if ( vNamesRegOut ) Vec_PtrFreeFree( vNamesRegOut ), vNamesRegOut = NULL;
if ( vNamesNode ) Vec_PtrFreeFree( vNamesNode ), vNamesNode = NULL;
}
}
else
@ -976,6 +989,10 @@ Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSi
vNamesRegIn = NULL;
}
}
if ( vNamesNode && Gia_ManObjNum(pNew) != Vec_PtrSize(vNamesNode) )
Abc_Print( 0, "The size of the node name array does not match the number of objects. Names are not entered.\n" );
else if ( vNamesNode )
pNew->vNamesNode = vNamesNode, vNamesNode = NULL;
if ( vNamesIn ) Vec_PtrFreeFree( vNamesIn );
if ( vNamesOut ) Vec_PtrFreeFree( vNamesOut );
if ( vNamesRegIn ) Vec_PtrFreeFree( vNamesRegIn );
@ -1311,6 +1328,14 @@ void Gia_AigerWrite( Gia_Man_t * pInit, char * pFileName, int fWriteSymbols, int
Gia_ManForEachPo( p, pObj, i )
fprintf( pFile, "o%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesOut, i) );
}
if ( p->vNamesNode && Vec_PtrSize(p->vNamesNode) != Gia_ManObjNum(p) )
Abc_Print( 0, "The size of the node name array does not match the number of objects. Names are not written.\n" );
else if ( p->vNamesNode )
{
Gia_ManForEachAnd( p, pObj, i )
if ( Vec_PtrEntry(p->vNamesNode, i) )
fprintf( pFile, "n%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesNode, i) );
}
// write the comment
if ( fWriteNewLine )

46
src/aig/gia/giaDup.c
View File

@ -1608,6 +1608,52 @@ Gia_Man_t * Gia_ManDupDfsOnePo( Gia_Man_t * p, int iPo )
return pNew;
}
/**Function*************************************************************
Synopsis [Duplicates the AIG in the DFS order.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManDupDfsRehash_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
{
if ( ~pObj->Value )
return;
assert( Gia_ObjIsAnd(pObj) );
Gia_ManDupDfsRehash_rec( pNew, p, Gia_ObjFanin0(pObj) );
Gia_ManDupDfsRehash_rec( pNew, p, Gia_ObjFanin1(pObj) );
pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
}
Gia_Man_t * Gia_ManDupDfsRehash( Gia_Man_t * p )
{
Gia_Man_t * pNew, * pTemp;
Gia_Obj_t * pObj;
int i;
pNew = Gia_ManStart( Gia_ManObjNum(p) );
pNew->pName = Abc_UtilStrsav( p->pName );
pNew->pSpec = Abc_UtilStrsav( p->pSpec );
Gia_ManFillValue( p );
Gia_ManConst0(p)->Value = 0;
Gia_ManForEachCi( p, pObj, i )
pObj->Value = Gia_ManAppendCi(pNew);
Gia_ManHashAlloc( pNew );
Gia_ManForEachCo( p, pObj, i )
Gia_ManDupDfsRehash_rec( pNew, p, Gia_ObjFanin0(pObj) );
Gia_ManForEachCo( p, pObj, i )
pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
pNew = Gia_ManCleanup( pTemp = pNew );
Gia_ManStop( pTemp );
Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
pNew->nConstrs = p->nConstrs;
if ( p->pCexSeq )
pNew->pCexSeq = Abc_CexDup( p->pCexSeq, Gia_ManRegNum(p) );
return pNew;
}
/**Function*************************************************************
Synopsis [Cofactors w.r.t. a primary input variable.]

3
src/aig/gia/giaIf.c
View File

@ -2222,10 +2222,11 @@ void Gia_ManTransferTiming( Gia_Man_t * p, Gia_Man_t * pGia )
p->DefOutReqs = pGia->DefOutReqs;
p->And2Delay = pGia->And2Delay;
}
if ( pGia->vNamesIn || pGia->vNamesOut )
if ( pGia->vNamesIn || pGia->vNamesOut || pGia->vNamesNode )
{
p->vNamesIn = pGia->vNamesIn; pGia->vNamesIn = NULL;
p->vNamesOut = pGia->vNamesOut; pGia->vNamesOut = NULL;
p->vNamesNode = pGia->vNamesNode; pGia->vNamesNode = NULL;
}
if ( pGia->vConfigs || pGia->pCellStr )
{

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

@ -90,6 +90,7 @@ void Gia_ManStop( Gia_Man_t * p )
assert( p->pManTime == NULL );
Vec_PtrFreeFree( p->vNamesIn );
Vec_PtrFreeFree( p->vNamesOut );
Vec_PtrFreeFree( p->vNamesNode );
Vec_IntFreeP( &p->vSwitching );
Vec_IntFreeP( &p->vSuper );
Vec_IntFreeP( &p->vStore );
@ -148,6 +149,7 @@ void Gia_ManStop( Gia_Man_t * p )
Vec_IntFreeP( &p->vCoReqs );
Vec_IntFreeP( &p->vCoArrs );
Vec_IntFreeP( &p->vCoAttrs );
Vec_IntFreeP( &p->vWeights );
Gia_ManStopP( &p->pAigExtra );
Vec_IntFree( p->vCis );
Vec_IntFree( p->vCos );
@ -202,6 +204,7 @@ double Gia_ManMemory( Gia_Man_t * p )
Memory += Vec_FltMemory( p->vOutReqs );
Memory += Vec_PtrMemory( p->vNamesIn );
Memory += Vec_PtrMemory( p->vNamesOut );
Memory += Vec_PtrMemory( p->vNamesNode );
return Memory;
}

114
src/aig/gia/giaResub.c
View File

@ -558,11 +558,11 @@ int Gia_ManConstructFromMap( Gia_Man_t * pNew, Vec_Int_t * vGates, int nVars, Ve
iLitRes = Vec_IntEntry( vCopy, Vec_IntSize(vGates)/2-1 );
return iLitRes;
}
Gia_Man_t * Gia_ManConstructFromGates( Vec_Wec_t * vFuncs, int nVars )
Gia_Man_t * Gia_ManConstructFromGates( Vec_Wec_t * vFuncs, int nDivs )
{
Vec_Int_t * vGates; int i, k, iLit;
Vec_Int_t * vCopy = Vec_IntAlloc( 100 );
Vec_Int_t * vUsed = Vec_IntStartFull( nVars );
Vec_Int_t * vUsed = Vec_IntStartFull( nDivs );
Gia_Man_t * pNew = Gia_ManStart( 100 );
pNew->pName = Abc_UtilStrsav( "resub" );
Vec_WecForEachLevel( vFuncs, vGates, i )
@ -571,7 +571,7 @@ Gia_Man_t * Gia_ManConstructFromGates( Vec_Wec_t * vFuncs, int nVars )
Vec_IntForEachEntry( vGates, iLit, k )
{
int iVar = Abc_Lit2Var(iLit);
if ( iVar > 0 && iVar < nVars && Vec_IntEntry(vUsed, iVar) == -1 )
if ( iVar > 0 && iVar < nDivs && Vec_IntEntry(vUsed, iVar) == -1 )
Vec_IntWriteEntry( vUsed, iVar, Gia_ManAppendCi(pNew) );
}
}
@ -580,16 +580,77 @@ Gia_Man_t * Gia_ManConstructFromGates( Vec_Wec_t * vFuncs, int nVars )
int iLitRes, iTopLit = Vec_IntEntryLast( vGates );
if ( Abc_Lit2Var(iTopLit) == 0 )
iLitRes = 0;
else if ( Abc_Lit2Var(iTopLit) < nVars )
iLitRes = Gia_ManAppendCi(pNew);
else if ( Abc_Lit2Var(iTopLit) < nDivs )
iLitRes = Vec_IntEntry( vUsed, Abc_Lit2Var(iTopLit) );
else
iLitRes = Gia_ManConstructFromMap( pNew, vGates, nVars, vUsed, vCopy, 0 );
iLitRes = Gia_ManConstructFromMap( pNew, vGates, nDivs, vUsed, vCopy, 0 );
Gia_ManAppendCo( pNew, Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iTopLit) ) );
}
Vec_IntFree( vCopy );
Vec_IntFree( vUsed );
return pNew;
}
Gia_Man_t * Gia_ManConstructFromGates2( Vec_Wec_t * vFuncs, Vec_Wec_t * vDivs, int nObjs, Vec_Int_t ** pvSupp )
{
Vec_Int_t * vGates; int i, k, iVar, iLit;
Vec_Int_t * vSupp = Vec_IntAlloc( 100 );
Vec_Int_t * vCopy = Vec_IntAlloc( 100 );
Vec_Wec_t * vUseds = Vec_WecStart( Vec_WecSize(vDivs) );
Vec_Int_t * vMap = Vec_IntStartFull( nObjs );
Gia_Man_t * pNew = Gia_ManStart( 100 );
pNew->pName = Abc_UtilStrsav( "resub" );
assert( Vec_WecSize(vFuncs) == Vec_WecSize(vDivs) );
Vec_WecForEachLevel( vFuncs, vGates, i )
{
Vec_Int_t * vDiv = Vec_WecEntry( vDivs, i );
assert( Vec_IntSize(vGates) % 2 == 1 );
Vec_IntForEachEntry( vGates, iLit, k )
{
int iVar = Abc_Lit2Var(iLit);
if ( iVar > 0 && iVar < Vec_IntSize(vDiv) && Vec_IntEntry(vMap, Vec_IntEntry(vDiv, iVar)) == -1 )
Vec_IntWriteEntry( vMap, Vec_IntPushReturn(vSupp, Vec_IntEntry(vDiv, iVar)), 0 );
}
}
Vec_IntSort( vSupp, 0 );
Vec_IntForEachEntry( vSupp, iVar, k )
Vec_IntWriteEntry( vMap, iVar, Gia_ManAppendCi(pNew) );
Vec_WecForEachLevel( vFuncs, vGates, i )
{
Vec_Int_t * vDiv = Vec_WecEntry( vDivs, i );
Vec_Int_t * vUsed = Vec_WecEntry( vUseds, i );
Vec_IntFill( vUsed, Vec_IntSize(vDiv), -1 );
Vec_IntForEachEntry( vGates, iLit, k )
{
int iVar = Abc_Lit2Var(iLit);
if ( iVar > 0 && iVar < Vec_IntSize(vDiv) )
{
assert( Vec_IntEntry(vMap, Vec_IntEntry(vDiv, iVar)) > 0 );
Vec_IntWriteEntry( vUsed, iVar, Vec_IntEntry(vMap, Vec_IntEntry(vDiv, iVar)) );
}
}
}
Vec_WecForEachLevel( vFuncs, vGates, i )
{
Vec_Int_t * vDiv = Vec_WecEntry( vDivs, i );
Vec_Int_t * vUsed = Vec_WecEntry( vUseds, i );
int iLitRes, iTopLit = Vec_IntEntryLast( vGates );
if ( Abc_Lit2Var(iTopLit) == 0 )
iLitRes = 0;
else if ( Abc_Lit2Var(iTopLit) < Vec_IntSize(vDiv) )
iLitRes = Vec_IntEntry( vUsed, Abc_Lit2Var(iTopLit) );
else
iLitRes = Gia_ManConstructFromMap( pNew, vGates, Vec_IntSize(vDiv), vUsed, vCopy, 0 );
Gia_ManAppendCo( pNew, Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iTopLit) ) );
}
Vec_IntFree( vMap );
Vec_IntFree( vCopy );
Vec_WecFree( vUseds );
if ( pvSupp )
*pvSupp = vSupp;
else
Vec_IntFree( vSupp );
return pNew;
}
/**Function*************************************************************
@ -1118,11 +1179,13 @@ int Gia_ManResubAddNode( Gia_ResbMan_t * p, int iLit0, int iLit1, int Type )
Vec_IntPushTwo( p->vGates, Abc_LitNotCond(iFan0, Type==1), Abc_LitNotCond(iFan1, Type==1) );
return Abc_Var2Lit( iNode, Type==1 );
}
int Gia_ManResubPerformMux_rec( Gia_ResbMan_t * p, int nLimit )
int Gia_ManResubPerformMux_rec( Gia_ResbMan_t * p, int nLimit, int Depth )
{
extern int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit );
extern int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit, int Depth );
int iDivBest, iResLit0, iResLit1, nNodes;
word * pDiv, * pCopy[2];
if ( Depth == 0 )
return -1;
if ( nLimit < 3 )
return -1;
iDivBest = Gia_ManResubFindBestBinate( p );
@ -1136,7 +1199,10 @@ int Gia_ManResubPerformMux_rec( Gia_ResbMan_t * p, int nLimit )
Abc_TtAndSharp( p->pSets[0], pCopy[0], pDiv, p->nWords, !Abc_LitIsCompl(iDivBest) );
Abc_TtAndSharp( p->pSets[1], pCopy[1], pDiv, p->nWords, !Abc_LitIsCompl(iDivBest) );
nNodes = Vec_IntSize(p->vGates)/2;
iResLit0 = Gia_ManResubPerform_rec( p, nLimit-3 );
//iResLit0 = Gia_ManResubPerform_rec( p, nLimit-3 );
iResLit0 = Gia_ManResubPerform_rec( p, nLimit, 0 );
if ( iResLit0 == -1 )
iResLit0 = Gia_ManResubPerformMux_rec( p, nLimit, Depth-1 );
if ( iResLit0 == -1 )
{
ABC_FREE( pCopy[0] );
@ -1150,7 +1216,10 @@ int Gia_ManResubPerformMux_rec( Gia_ResbMan_t * p, int nLimit )
nNodes = Vec_IntSize(p->vGates)/2 - nNodes;
if ( nLimit-nNodes < 3 )
return -1;
iResLit1 = Gia_ManResubPerform_rec( p, nLimit-3-nNodes );
//iResLit1 = Gia_ManResubPerform_rec( p, nLimit-3-nNodes );
iResLit1 = Gia_ManResubPerform_rec( p, nLimit, 0 );
if ( iResLit1 == -1 )
iResLit1 = Gia_ManResubPerformMux_rec( p, nLimit, Depth-1 );
if ( iResLit1 == -1 )
return -1;
else
@ -1172,7 +1241,7 @@ int Gia_ManResubPerformMux_rec( Gia_ResbMan_t * p, int nLimit )
SeeAlso []
***********************************************************************/
int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit )
int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit, int Depth )
{
int TopOneW[2] = {0}, TopTwoW[2] = {0}, Max1, Max2, iResLit, nVars = Vec_PtrSize(p->vDivs);
if ( p->fVerbose )
@ -1205,7 +1274,8 @@ int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit )
return Abc_Var2Lit( iNode, fComp );
}
Vec_IntTwoFindCommon( p->vNotUnateVars[0], p->vNotUnateVars[1], p->vBinateVars );
//return Gia_ManResubPerformMux_rec( p, nLimit );
if ( Depth )
return Gia_ManResubPerformMux_rec( p, nLimit, Depth );
if ( Vec_IntSize(p->vBinateVars) > p->nDivsMax )
Vec_IntShrink( p->vBinateVars, p->nDivsMax );
if ( p->fVerbose ) printf( " B = %3d", Vec_IntSize(p->vBinateVars) );
@ -1304,7 +1374,7 @@ int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit )
Abc_TtAndSharp( p->pSets[fUseOr], p->pSets[fUseOr], pDiv, p->nWords, !fComp );
if ( p->fVerbose )
printf( "\n" );
iResLit = Gia_ManResubPerform_rec( p, nLimit-1 );
iResLit = Gia_ManResubPerform_rec( p, nLimit-1, Depth );
if ( iResLit >= 0 )
{
int iNode = nVars + Vec_IntSize(p->vGates)/2;
@ -1348,7 +1418,7 @@ int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit )
Abc_TtAndSharp( p->pSets[fUseOr], p->pSets[fUseOr], p->pDivA, p->nWords, !fComp );
if ( p->fVerbose )
printf( "\n" );
iResLit = Gia_ManResubPerform_rec( p, nLimit-2 );
iResLit = Gia_ManResubPerform_rec( p, nLimit-2, Depth );
if ( iResLit >= 0 )
{
int iNode = nVars + Vec_IntSize(p->vGates)/2;
@ -1383,11 +1453,11 @@ int Gia_ManResubPerform_rec( Gia_ResbMan_t * p, int nLimit )
}
return -1;
}
void Gia_ManResubPerform( Gia_ResbMan_t * p, Vec_Ptr_t * vDivs, int nWords, int nLimit, int nDivsMax, int iChoice, int fUseXor, int fDebug, int fVerbose )
void Gia_ManResubPerform( Gia_ResbMan_t * p, Vec_Ptr_t * vDivs, int nWords, int nLimit, int nDivsMax, int iChoice, int fUseXor, int fDebug, int fVerbose, int Depth )
{
int Res;
Gia_ResbInit( p, vDivs, nWords, nLimit, nDivsMax, iChoice, fUseXor, fDebug, fVerbose, fVerbose );
Res = Gia_ManResubPerform_rec( p, nLimit );
Res = Gia_ManResubPerform_rec( p, nLimit, Depth );
if ( Res >= 0 )
Vec_IntPush( p->vGates, Res );
else
@ -1395,11 +1465,11 @@ void Gia_ManResubPerform( Gia_ResbMan_t * p, Vec_Ptr_t * vDivs, int nWords, int
if ( fVerbose )
printf( "\n" );
}
Vec_Int_t * Gia_ManResubOne( Vec_Ptr_t * vDivs, int nWords, int nLimit, int nDivsMax, int iChoice, int fUseXor, int fDebug, int fVerbose, word * pFunc )
Vec_Int_t * Gia_ManResubOne( Vec_Ptr_t * vDivs, int nWords, int nLimit, int nDivsMax, int iChoice, int fUseXor, int fDebug, int fVerbose, word * pFunc, int Depth )
{
Vec_Int_t * vRes;
Gia_ResbMan_t * p = Gia_ResbAlloc( nWords );
Gia_ManResubPerform( p, vDivs, nWords, nLimit, nDivsMax, iChoice, fUseXor, fDebug, fVerbose );
Gia_ManResubPerform( p, vDivs, nWords, nLimit, nDivsMax, iChoice, fUseXor, fDebug, fVerbose, Depth );
if ( fVerbose )
Gia_ManResubPrint( p->vGates, Vec_PtrSize(vDivs) );
if ( fVerbose )
@ -1444,7 +1514,7 @@ int Abc_ResubComputeFunction( void ** ppDivs, int nDivs, int nWords, int nLimit,
{
Vec_Ptr_t Divs = { nDivs, nDivs, ppDivs };
assert( s_pResbMan != NULL ); // first call Abc_ResubPrepareManager()
Gia_ManResubPerform( s_pResbMan, &Divs, nWords, nLimit, nDivsMax, iChoice, fUseXor, fDebug, fVerbose==2 );
Gia_ManResubPerform( s_pResbMan, &Divs, nWords, nLimit, nDivsMax, iChoice, fUseXor, fDebug, fVerbose==2, 0 );
if ( fVerbose )
{
int nGates = Vec_IntSize(s_pResbMan->vGates)/2;
@ -1563,7 +1633,7 @@ void Gia_ManResubTest3_()
printf( " " );
Dau_DsdPrintFromTruth2( &Truth, 6 );
printf( " " );
Gia_ManResubPerform( p, vDivs, 1, 100, 0, 50, 1, 1, 0 );
Gia_ManResubPerform( p, vDivs, 1, 100, 0, 50, 1, 1, 0, 0 );
}
Gia_ResbFree( p );
Vec_IntFree( vRes );
@ -1604,7 +1674,7 @@ void Gia_ManResubPair( Vec_Wrd_t * vOn, Vec_Wrd_t * vOff, int nWords, int nIns )
memmove( pSim+nWords, Vec_WrdEntryP(vOff, (i-2)*nWords), sizeof(word)*nWords );
}
}
Gia_ManResubPerform( p, vDivs, nWords*2, 100, 0, 50, 1, 1, 0 );
Gia_ManResubPerform( p, vDivs, nWords*2, 100, 0, 50, 1, 1, 0, 0 );
Gia_ManResubPrint( p->vGates, Vec_PtrSize(vDivs) );
printf( "\n" );
//Vec_PtrFree( vDivs );
@ -1672,7 +1742,7 @@ Gia_Man_t * Gia_ManResub1( char * pFileName, int nNodes, int nSupp, int nDivs, i
Vec_PtrShrink( vDivs, (1<<14)-1 );
}
assert( Vec_PtrSize(vDivs) < (1<<14) );
Gia_ManResubPerform( p, vDivs, nWords, 100, 50, iChoice, fUseXor, 1, 1 );
Gia_ManResubPerform( p, vDivs, nWords, 100, 50, iChoice, fUseXor, 1, 1, 0 );
if ( Vec_IntSize(p->vGates) )
{
Vec_Wec_t * vGates = Vec_WecStart(1);

22
src/aig/gia/giaSimBase.c
View File

@ -134,6 +134,27 @@ Vec_Wrd_t * Gia_ManSimPatSim( Gia_Man_t * pGia )
Gia_ManSimPatSimPo( pGia, Gia_ObjId(pGia, pObj), pObj, nWords, vSims );
return vSims;
}
Vec_Wrd_t * Gia_ManSimPatSimOut( Gia_Man_t * pGia, Vec_Wrd_t * vSimsPi, int fOuts )
{
Gia_Obj_t * pObj;
int i, nWords = Vec_WrdSize(vSimsPi) / Gia_ManCiNum(pGia);
Vec_Wrd_t * vSimsCo = fOuts ? Vec_WrdStart( Gia_ManCoNum(pGia) * nWords ) : NULL;
Vec_Wrd_t * vSims = Vec_WrdStart( Gia_ManObjNum(pGia) * nWords );
assert( Vec_WrdSize(vSimsPi) % Gia_ManCiNum(pGia) == 0 );
Gia_ManSimPatAssignInputs( pGia, nWords, vSims, vSimsPi );
Gia_ManForEachAnd( pGia, pObj, i )
Gia_ManSimPatSimAnd( pGia, i, pObj, nWords, vSims );
Gia_ManForEachCo( pGia, pObj, i )
Gia_ManSimPatSimPo( pGia, Gia_ObjId(pGia, pObj), pObj, nWords, vSims );
Gia_ManForEachCo( pGia, pObj, i )
Gia_ManSimPatSimPo( pGia, Gia_ObjId(pGia, pObj), pObj, nWords, vSims );
if ( !fOuts )
return vSims;
Gia_ManForEachCo( pGia, pObj, i )
memcpy( Vec_WrdEntryP(vSimsCo, i*nWords), Vec_WrdEntryP(vSims, Gia_ObjId(pGia, pObj)*nWords), sizeof(word)*nWords );
Vec_WrdFree( vSims );
return vSimsCo;
}
void Gia_ManSimPatResim( Gia_Man_t * pGia, Vec_Int_t * vObjs, int nWords, Vec_Wrd_t * vSims )
{
Gia_Obj_t * pObj; int i;
@ -550,7 +571,6 @@ Vec_Wrd_t * Gia_ManSimBitPacking( Gia_Man_t * p, Vec_Int_t * vCexStore, int nCex
return vSimsRes;
}
/**Function*************************************************************
Synopsis []

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

@ -770,6 +770,11 @@ void Abc_FrameUpdateGia( Abc_Frame_t * pAbc, Gia_Man_t * pNew )
pNew->vNamesOut = pAbc->pGia->vNamesOut;
pAbc->pGia->vNamesOut = NULL;
}
if (!pNew->vNamesNode && pAbc->pGia && pAbc->pGia->vNamesNode && Gia_ManObjNum(pNew) == Vec_PtrSize(pAbc->pGia->vNamesNode))
{
pNew->vNamesNode = pAbc->pGia->vNamesNode;
pAbc->pGia->vNamesNode = NULL;
}
// update
if ( pAbc->pGia2 )
Gia_ManStop( pAbc->pGia2 );
@ -30088,6 +30093,7 @@ int Abc_CommandAbc9Read( Abc_Frame_t * pAbc, int argc, char ** argv )
{
extern void Abc3_ReadShowHie( char * pFileName, int fFlat );
extern Gia_Man_t * Gia_MiniAigSuperDerive( char * pFileName, int fVerbose );
extern Gia_Man_t * Gia_FileSimpleRead( char * pFileName, int fNames, char * pFileW );
Gia_Man_t * pAig = NULL;
FILE * pFile;
char ** pArgvNew;
@ -30099,8 +30105,9 @@ int Abc_CommandAbc9Read( Abc_Frame_t * pAbc, int argc, char ** argv )
int fVerbose = 0;
int fGiaSimple = 0;
int fSkipStrash = 0;
int fNewReader = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "csmnlvh" ) ) != EOF )
while ( ( c = Extra_UtilGetopt( argc, argv, "csmnlpvh" ) ) != EOF )
{
switch ( c )
{
@ -30119,6 +30126,9 @@ int Abc_CommandAbc9Read( Abc_Frame_t * pAbc, int argc, char ** argv )
case 'l':
fMiniLut ^= 1;
break;
case 'p':
fNewReader ^= 1;
break;
case 'v':
fVerbose ^= 1;
break;
@ -30150,7 +30160,9 @@ int Abc_CommandAbc9Read( Abc_Frame_t * pAbc, int argc, char ** argv )
}
fclose( pFile );
if ( fMiniAig )
if ( fNewReader )
pAig = Gia_FileSimpleRead( FileName, fGiaSimple, NULL );
else if ( fMiniAig )
pAig = Gia_ManReadMiniAig( FileName );
else if ( fMiniAig2 )
pAig = Gia_MiniAigSuperDerive( FileName, fVerbose );
@ -30702,6 +30714,8 @@ int Abc_CommandAbc9Put( Abc_Frame_t * pAbc, int argc, char ** argv )
}
}
}
if ( pAbc->pGia->vNamesNode )
Abc_Print( 0, "Internal nodes names are not transferred.\n" );
// decouple CI/CO with the same name
if ( pAbc->pGia->vNamesIn || pAbc->pGia->vNamesOut )

258
src/base/acb/acbFunc.c
View File

@ -210,17 +210,78 @@ Vec_Int_t * Acb_VerilogSimpleLex( char * pFileName, Abc_Nam_t * pNames )
Vec_Int_t * vBuffer = Vec_IntAlloc( 1000 );
char * pBuffer = Extra_FileReadContents( pFileName );
char * pToken, * pStart, * pLimit = pBuffer + strlen(pBuffer);
int i, iToken, RLeft = -1, RRight = -1;
if ( pBuffer == NULL )
return NULL;
Acb_VerilogRemoveComments( pBuffer );
pToken = strtok( pBuffer, " \n\r\t(),;=" );
while ( pToken )
{
int iToken = Abc_NamStrFindOrAdd( pNames, pToken, NULL );
if ( 0 )
{
if ( !strcmp(pToken, "assign") )
{
int fBuffer = 0;
int nToks = 0, pToks[4];
while ( 1 )
{
pToken = strtok( NULL, " \n\r\t(),=~&" );
if ( pToken[0] == ';' )
break;
if ( pToken[strlen(pToken)-1] == ';' )
{
pToken[strlen(pToken)-1] = 0;
assert( nToks < 3 );
pToks[nToks++] = Abc_NamStrFindOrAdd( pNames, pToken, NULL );
fBuffer = 1;
break;
}
else
{
assert( nToks < 3 );
pToks[nToks++] = Abc_NamStrFindOrAdd( pNames, pToken, NULL );
}
}
assert( nToks == 2 || nToks == 3 );
Vec_IntPush( vBuffer, fBuffer ? ACB_AND : ACB_NAND );
Vec_IntPush( vBuffer, pToks[0] );
Vec_IntPush( vBuffer, pToks[1] );
Vec_IntPush( vBuffer, nToks == 3 ? pToks[2] : pToks[1] );
pToken = strtok( NULL, " \n\r\t(),;=" );
continue;
}
}
if ( pToken[0] == '[' )
{
assert( RLeft == -1 );
RLeft = atoi(pToken+1);
RRight = atoi(strstr(pToken,":")+1);
pToken = strtok( NULL, " \n\r\t(),;=" );
continue;
}
if ( pToken[0] == '\\' )
pToken++;
if ( !strcmp(pToken, "assign") )
Vec_IntPush( vBuffer, ACB_BUF );
iToken = ACB_BUF;
else
Vec_IntPush( vBuffer, iToken );
iToken = Abc_NamStrFindOrAdd( pNames, pToken, NULL );
if ( iToken < ACB_UNUSED )
RLeft = RRight = -1;
else if ( RLeft != -1 )
{
char Buffer[1000];
assert( strlen(pToken) < 990 );
for ( i = RRight; i <= RLeft; i++ )
{
sprintf( Buffer, "%s[%d]", pToken, i );
iToken = Abc_NamStrFindOrAdd( pNames, Buffer, NULL );
Vec_IntPush( vBuffer, iToken );
}
pToken = strtok( NULL, " \n\r\t(),;=" );
continue;
}
Vec_IntPush( vBuffer, iToken );
if ( iToken >= ACB_BUF && iToken < ACB_UNUSED )
{
for ( pStart = pToken; pStart < pLimit && *pStart != '\n'; pStart++ )
@ -326,6 +387,178 @@ void * Acb_VerilogSimpleParse( Vec_Int_t * vBuffer, Abc_Nam_t * pNames )
return pDesign;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Gia_FileSimpleParse_rec( Gia_Man_t * pNew, int Token, Vec_Int_t * vMapType, Vec_Int_t * vTypes, Vec_Int_t * vFanins, Vec_Int_t * vMap )
{
int nFanins, * pFanins, pLits[16];
int i, Type, Size, Place = Vec_IntEntry( vMapType, Token );
int iLit = Vec_IntEntry( vMap, Token );
if ( iLit >= 0 )
return iLit;
Place = Vec_IntEntry( vMapType, Token );
assert( Place >= 0 );
Type = Vec_IntEntry( vTypes, Place );
Size = Vec_IntEntry( vTypes, Place+1 );
nFanins = Vec_IntEntry(vTypes, Place+3) - Size - 1;
pFanins = Vec_IntEntryP(vFanins, Size+1);
assert( nFanins > 0 && nFanins < 16 );
for ( i = 0; i < nFanins; i++ )
Gia_FileSimpleParse_rec( pNew, pFanins[i], vMapType, vTypes, vFanins, vMap );
for ( i = 0; i < nFanins; i++ )
pLits[i] = Vec_IntEntry( vMap, pFanins[i] );
if ( nFanins == 1 )
{
assert( Type == ACB_BUF || Type == ACB_NOT );
iLit = Abc_LitNotCond( pLits[0], Type == ACB_NOT );
iLit = Gia_ManAppendAnd2( pNew, iLit, iLit );
}
else
{
iLit = pLits[0];
if ( Type == ACB_AND || Type == ACB_NAND )
for ( i = 1; i < nFanins; i++ )
iLit = Gia_ManAppendAnd2( pNew, iLit, pLits[i] );
else if ( Type == ACB_OR || Type == ACB_NOR )
for ( i = 1; i < nFanins; i++ )
iLit = Gia_ManAppendOr2( pNew, iLit, pLits[i] );
else if ( Type == ACB_XOR || Type == ACB_XNOR )
for ( i = 1; i < nFanins; i++ )
iLit = Gia_ManAppendXor2( pNew, iLit, pLits[i] );
else assert( 0 );
iLit = Abc_LitNotCond( iLit, (Type == ACB_NAND || Type == ACB_NOR || Type == ACB_XNOR) );
}
Vec_IntWriteEntry( vMap, Token, iLit );
return iLit;
}
Gia_Man_t * Gia_FileSimpleParse( Vec_Int_t * vBuffer, Abc_Nam_t * pNames, int fNames, char * pFileW )
{
Gia_Man_t * pNew = NULL;
Vec_Int_t * vInputs = Vec_IntAlloc(100);
Vec_Int_t * vOutputs = Vec_IntAlloc(100);
Vec_Int_t * vWires = Vec_IntAlloc(100);
Vec_Int_t * vTypes = Vec_IntAlloc(100);
Vec_Int_t * vFanins = Vec_IntAlloc(100);
Vec_Int_t * vCur = NULL;
Vec_Int_t * vMap = Vec_IntStartFull( Abc_NamObjNumMax(pNames) );
Vec_Int_t * vMapType = Vec_IntStartFull( Abc_NamObjNumMax(pNames) );
int i, iLit, Token, Size;
char Buffer[1000];
assert( Vec_IntEntry(vBuffer, 0) == ACB_MODULE );
Vec_IntForEachEntryStart( vBuffer, Token, i, 2 )
{
if ( vCur == NULL && Token >= ACB_UNUSED )
continue;
if ( Token == ACB_ENDMODULE )
break;
if ( Token == ACB_INPUT )
vCur = vInputs;
else if ( Token == ACB_OUTPUT )
vCur = vOutputs;
else if ( Token == ACB_WIRE )
vCur = vWires;
else if ( Token >= ACB_BUF && Token < ACB_UNUSED )
{
Vec_IntPush( vTypes, Token );
Vec_IntPush( vTypes, Vec_IntSize(vFanins) );
vCur = vFanins;
}
else
Vec_IntPush( vCur, Token );
}
Vec_IntPush( vTypes, -1 );
Vec_IntPush( vTypes, Vec_IntSize(vFanins) );
// map types
Vec_IntForEachEntryDouble( vTypes, Token, Size, i )
if ( Token > 0 )
Vec_IntWriteEntry( vMapType, Vec_IntEntry(vFanins, Size), i );
// create design
pNew = Gia_ManStart( 10000 );
pNew->pName = Abc_UtilStrsav( Abc_NamStr(pNames, Vec_IntEntry(vBuffer, 1)) );
pNew->fGiaSimple = 1;
if ( (Token = Abc_NamStrFind(pNames, "1\'b0")) )
Vec_IntWriteEntry( vMap, Token, 0 );
if ( (Token = Abc_NamStrFind(pNames, "1\'b1")) )
Vec_IntWriteEntry( vMap, Token, 1 );
if ( (Token = Abc_NamStrFind(pNames, "1\'bx")) )
Vec_IntWriteEntry( vMap, Token, 0 );
if ( (Token = Abc_NamStrFind(pNames, "1\'bz")) )
Vec_IntWriteEntry( vMap, Token, 0 );
Vec_IntForEachEntry( vInputs, Token, i )
Gia_ManAppendCi(pNew);
Vec_IntForEachEntry( vInputs, Token, i )
Vec_IntWriteEntry( vMap, Token, Gia_ManAppendAnd2(pNew, Gia_ManCiLit(pNew, i), Gia_ManCiLit(pNew, i)) );
Vec_IntForEachEntry( vOutputs, Token, i )
Gia_FileSimpleParse_rec( pNew, Token, vMapType, vTypes, vFanins, vMap );
Vec_IntForEachEntry( vOutputs, Token, i )
Gia_ManAppendCo( pNew, Vec_IntEntry(vMap, Token) );
// create names
if ( fNames )
{
pNew->vNamesNode = Vec_PtrStart( Gia_ManObjNum(pNew) );
Vec_IntForEachEntry( vMap, iLit, Token )
{
if ( iLit == -1 || !Gia_ObjIsAnd(Gia_ManObj(pNew, Abc_Lit2Var(iLit))) )
continue;
sprintf( Buffer, "%c_%s", Abc_LitIsCompl(iLit) ? 'c' : 'd', Abc_NamStr(pNames, Token) );
assert( Vec_PtrEntry(pNew->vNamesNode, Abc_Lit2Var(iLit)) == NULL );
Vec_PtrWriteEntry( pNew->vNamesNode, Abc_Lit2Var(iLit), Abc_UtilStrsav(Buffer) );
}
}
else
{
Gia_Man_t * pTemp;
pNew = Gia_ManDupDfsRehash( pTemp = pNew );
Gia_ManStop( pTemp );
}
pNew->vNamesIn = Vec_PtrAlloc( Vec_IntSize(vInputs) );
Vec_IntForEachEntry( vInputs, Token, i )
Vec_PtrPush( pNew->vNamesIn, Abc_UtilStrsav(Abc_NamStr(pNames, Token)) );
pNew->vNamesOut = Vec_PtrAlloc( Vec_IntSize(vOutputs) );
Vec_IntForEachEntry( vOutputs, Token, i )
Vec_PtrPush( pNew->vNamesOut, Abc_UtilStrsav(Abc_NamStr(pNames, Token)) );
if ( pFileW )
{
extern Vec_Int_t * Acb_ReadWeightMap( char * pFileName, Abc_Nam_t * pNames );
Vec_Int_t * vT2W = Acb_ReadWeightMap( pFileW, pNames );
assert( pNew->vWeights == NULL );
pNew->vWeights = Vec_IntStartFull( Gia_ManObjNum(pNew) );
Vec_IntForEachEntry( vMap, iLit, Token )
if ( iLit != -1 && Vec_IntEntry(vT2W, Token) != -1 )
Vec_IntWriteEntry( pNew->vWeights, Abc_Lit2Var(iLit), Vec_IntEntry(vT2W, Token) );
Vec_IntFree( vT2W );
}
// cleanup
Vec_IntFree( vInputs );
Vec_IntFree( vOutputs );
Vec_IntFree( vWires );
Vec_IntFree( vTypes );
Vec_IntFree( vFanins );
Vec_IntFree( vMap );
Vec_IntFree( vMapType );
return pNew;
}
Gia_Man_t * Gia_FileSimpleRead( char * pFileName, int fNames, char * pFileW )
{
Abc_Nam_t * pNames = Acb_VerilogStartNames();
Vec_Int_t * vBuffer = Acb_VerilogSimpleLex( pFileName, pNames );
Gia_Man_t * pNew = vBuffer ? Gia_FileSimpleParse( vBuffer, pNames, fNames, pFileW ) : NULL;
assert( pNew->pSpec == NULL );
pNew->pSpec = Abc_UtilStrsav( pFileName );
Abc_NamDeref( pNames );
Vec_IntFree( vBuffer );
return pNew;
}
/**Function*************************************************************
Synopsis [Read weights of nodes from the weight file.]
@ -374,10 +607,18 @@ Vec_Int_t * Acb_ReadWeightMap( char * pFileName, Abc_Nam_t * pNames )
SeeAlso []
***********************************************************************/
char ** Acb_PrepareNames( Abc_Nam_t * p )
{
char ** ppRes = ABC_CALLOC( char *, Abc_NamObjNumMax(p) );
int i;
for ( i = 0; i < Abc_NamObjNumMax(p); i++ )
ppRes[i] = Abc_NamStr( p, i );
return ppRes;
}
Acb_Ntk_t * Acb_VerilogSimpleRead( char * pFileName, char * pFileNameW )
{
extern Acb_Ntk_t * Acb_NtkFromNdr( char * pFileName, void * pModule, Abc_Nam_t * pNames, Vec_Int_t * vWeights, int nNameIdMax );
Acb_Ntk_t * pNtk;
Acb_Ntk_t * pNtk; //char ** ppNames;
Abc_Nam_t * pNames = Acb_VerilogStartNames();
Vec_Int_t * vBuffer = Acb_VerilogSimpleLex( pFileName, pNames );
void * pModule = vBuffer ? Acb_VerilogSimpleParse( vBuffer, pNames ) : NULL;
@ -392,7 +633,9 @@ Acb_Ntk_t * Acb_VerilogSimpleRead( char * pFileName, char * pFileNameW )
printf( "Cannot read weight file \"%s\".\n", pFileNameW );
return NULL;
}
// Ndr_ModuleWriteVerilog( "iccad17/unit1/test.v", pModule, pNameStrs );
//ppNames = Acb_PrepareNames(pNames);
//Ndr_WriteVerilog( Extra_FileNameGenericAppend(pFileName, "_ndr.v"), pModule, ppNames, 1 );
//ABC_FREE( ppNames );
pNtk = Acb_NtkFromNdr( pFileName, pModule, pNames, vWeights, Abc_NamObjNumMax(pNames) );
Ndr_Delete( pModule );
Vec_IntFree( vBuffer );
@ -400,6 +643,11 @@ Acb_Ntk_t * Acb_VerilogSimpleRead( char * pFileName, char * pFileNameW )
Abc_NamDeref( pNames );
return pNtk;
}
void Acb_VerilogSimpleReadTest( char * pFileName )
{
Acb_Ntk_t * p = Acb_VerilogSimpleRead( pFileName, NULL );
Acb_NtkFree( p );
}
/**Function*************************************************************

9
src/base/io/ioReadAiger.c
View File

@ -480,6 +480,7 @@ Abc_Ntk_t * Io_ReadAiger( char * pFileName, int fCheck )
if ( pCur < pContents + nFileSize && *pCur != 'c' )
{
int Counter = 0;
int fNodeNames = 0;
while ( pCur < pContents + nFileSize && *pCur != 'c' )
{
// get the terminal type
@ -490,6 +491,12 @@ Abc_Ntk_t * Io_ReadAiger( char * pFileName, int fCheck )
vTerms = pNtkNew->vBoxes;
else if ( *pCur == 'o' || *pCur == 'b' || *pCur == 'c' || *pCur == 'j' || *pCur == 'f' )
vTerms = pNtkNew->vPos;
else if ( *pCur == 'n' )
{
fNodeNames++;
while ( *pCur++ != '\n' );
continue;
}
else
{
// fprintf( stdout, "Wrong terminal type.\n" );
@ -543,6 +550,8 @@ Abc_Ntk_t * Io_ReadAiger( char * pFileName, int fCheck )
}
// if ( Counter )
// printf( "Io_ReadAiger(): Added %d default names for nameless I/O/register objects.\n", Counter );
if ( fNodeNames )
printf( "Io_ReadAiger(): The names of internal nodes are not supported. Ignoring %d node names.\n", fNodeNames );
}
else
{

1
src/misc/extra/extra.h
View File

@ -106,6 +106,7 @@ extern char * Extra_FileNameGenericAppend( char * pBase, char * pSuffix );
extern void Extra_FileNameCorrectPath( char * FileName );
extern char * Extra_FileNameWithoutPath( char * FileName );
extern char * Extra_FilePathWithoutName( char * FileName );
extern char * Extra_FileInTheSameDir( char * pPathFile, char * pFileName );
extern char * Extra_FileDesignName( char * pFileName );
extern int Extra_FileCheck( char * pFileName );
extern int Extra_FileSize( char * pFileName );

11
src/misc/extra/extraUtilFile.c
View File

@ -240,13 +240,22 @@ char * Extra_FilePathWithoutName( char * FileName )
for ( pRes = FileName + strlen(FileName) - 1; pRes >= FileName; pRes-- )
if ( *pRes == '\\' || *pRes == '/' )
{
*pRes = 0;
pRes[1] = '\0';
Extra_FileNameCorrectPath( FileName );
return FileName;
}
ABC_FREE( FileName );
return NULL;
}
char * Extra_FileInTheSameDir( char * pPathFile, char * pFileName )
{
static char pBuffer[1000];
char * pPath = Extra_FilePathWithoutName( pPathFile );
assert( strlen(pPath) + strlen(pFileName) < 990 );
sprintf( pBuffer, "%s%s", pPath, pFileName );
ABC_FREE( pPath );
return pBuffer;
}
char * Extra_FileDesignName( char * pFileName )
{
char * pBeg, * pEnd, * pStore, * pCur;

2
src/misc/util/abc_global.h
View File

@ -288,6 +288,8 @@ static inline int Abc_Base2Log( unsigned n ) { int r; if ( n <
static inline int Abc_Base10Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
static inline int Abc_Base16Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
static inline char * Abc_UtilStrsav( char * s ) { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL; }
static inline char * Abc_UtilStrsavTwo( char * s, char * a ){ char * r; if (!a) return Abc_UtilStrsav(s); r = ABC_ALLOC(char, strlen(s)+strlen(a)+1); sprintf(r, "%s%s", s, a ); return r; }
static inline char * Abc_UtilStrsavNum( char * s, int n ) { char * r; if (!s) return NULL; r = ABC_ALLOC(char, strlen(s)+12+1); sprintf(r, "%s%d", s, n ); return r; }
static inline int Abc_BitByteNum( int nBits ) { return (nBits>>3) + ((nBits&7) > 0); }
static inline int Abc_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); }
static inline int Abc_Bit6WordNum( int nBits ) { return (nBits>>6) + ((nBits&63) > 0); }

6
src/misc/util/utilTruth.h
View File

@ -344,6 +344,12 @@ static inline void Abc_TtOrXor( word * pOut, word * pIn1, word * pIn2, int nWord
for ( w = 0; w < nWords; w++ )
pOut[w] |= pIn1[w] ^ pIn2[w];
}
static inline void Abc_TtAndXor( word * pOut, word * pIn1, word * pIn2, int nWords )
{
int w;
for ( w = 0; w < nWords; w++ )
pOut[w] &= pIn1[w] ^ pIn2[w];
}
static inline void Abc_TtOrAnd( word * pOut, word * pIn1, word * pIn2, int nWords )
{
int w;

35
src/misc/vec/vecInt.h
View File

@ -150,6 +150,23 @@ static inline Vec_Int_t * Vec_IntStartRange( int First, int Range )
p->pArray[i] = First + i;
return p;
}
static inline Vec_Int_t * Vec_IntStartRandomLimit( int nSize, int Upper, int Lower )
{
Vec_Int_t * p = Vec_IntAlloc( nSize );
int i, Gap = Upper - Lower + 1;
for ( i = 0; i < p->nSize; i++ )
p->pArray[i] = Lower + Abc_Random(0) % Gap;
return p;
}
static inline void Vec_IntRandomizeOrder( Vec_Int_t * p )
{
int v;
for ( v = 0; v < p->nSize; v++ )
{
int vRand = Abc_Random(0) % p->nSize;
ABC_SWAP( int, p->pArray[vRand], p->pArray[v] );
}
}
/**Function*************************************************************
@ -734,6 +751,11 @@ static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
}
p->pArray[p->nSize++] = Entry;
}
static inline int Vec_IntPushReturn( Vec_Int_t * p, int Entry )
{
Vec_IntPush( p, Entry );
return Entry;
}
static inline void Vec_IntPushTwo( Vec_Int_t * p, int Entry1, int Entry2 )
{
Vec_IntPush( p, Entry1 );
@ -1318,6 +1340,19 @@ static inline int Vec_IntEqual( Vec_Int_t * p1, Vec_Int_t * p2 )
return 0;
return 1;
}
static inline int Vec_IntContained( Vec_Int_t * pSmall, Vec_Int_t * pLarge )
{
int i, k;
for ( i = 0; i < pSmall->nSize; i++ )
{
for ( k = 0; k < pLarge->nSize; k++ )
if ( pSmall->pArray[i] == pLarge->pArray[k] )
break;
if ( k == pLarge->nSize )
return 0;
}
return 1;
}
/**Function*************************************************************

7
src/misc/vec/vecWec.h
View File

@ -275,6 +275,13 @@ static inline void Vec_WecClear( Vec_Wec_t * p )
Vec_IntClear( vVec );
p->nSize = 0;
}
static inline void Vec_WecClearLevels( Vec_Wec_t * p )
{
Vec_Int_t * vVec;
int i;
Vec_WecForEachLevel( p, vVec, i )
Vec_IntClear( vVec );
}
/**Function*************************************************************