Skip to content

A
abc
Commit c03f9b51 by Alan Mishchenko
Options

Version abc90220

parent 28d4f869
Showing with 345 additions and 66 deletions
abclib.dsp
......@@ -3663,10 +3663,6 @@ SOURCE=.\src\aig\gia\giaSim.c
# End Source File
# Begin Source File
SOURCE=.\src\aig\gia\giaSolver.c
# End Source File
# Begin Source File
SOURCE=.\src\aig\gia\giaSort.c
# End Source File
# Begin Source File
......
src/aig/aig/aigUtil.c
......@@ -1084,6 +1084,8 @@ char * Aig_FileNameGenericAppend( char * pBase, char * pSuffix )
if ( (pDot = strrchr( Buffer, '.' )) )
*pDot = 0;
strcat( Buffer, pSuffix );
if ( (pDot = strrchr( Buffer, '\\' )) || (pDot = strrchr( Buffer, '/' )) )
return pDot+1;
return Buffer;
}
......
src/aig/cec/cecSolve.c
......@@ -444,7 +444,8 @@ p->timeSatUnsat += clock() - clk;
RetValue = sat_solver_addclause( p->pSat, &Lit, &Lit + 1 );
assert( RetValue );
p->nSatUnsat++;
p->nConfUnsat += p->pSat->stats.conflicts - nConflicts;
p->nConfUnsat += p->pSat->stats.conflicts - nConflicts;
//printf( "UNSAT after %d conflicts\n", p->pSat->stats.conflicts - nConflicts );
return 1;
}
else if ( RetValue == l_True )
......@@ -452,6 +453,7 @@ p->timeSatUnsat += clock() - clk;
p->timeSatSat += clock() - clk;
p->nSatSat++;
p->nConfSat += p->pSat->stats.conflicts - nConflicts;
//printf( "SAT after %d conflicts\n", p->pSat->stats.conflicts - nConflicts );
return 0;
}
else // if ( RetValue == l_Undef )
......@@ -459,6 +461,7 @@ p->timeSatSat += clock() - clk;
p->timeSatUndec += clock() - clk;
p->nSatUndec++;
p->nConfUndec += p->pSat->stats.conflicts - nConflicts;
//printf( "UNDEC after %d conflicts\n", p->pSat->stats.conflicts - nConflicts );
return -1;
}
}
......@@ -477,10 +480,18 @@ p->timeSatUndec += clock() - clk;
***********************************************************************/
void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPars )
{
static int Counter;
// char Buffer[1000];
Bar_Progress_t * pProgress = NULL;
Cec_ManSat_t * p;
Gia_Obj_t * pObj;
int i, status, clk = clock();
// sprintf( Buffer, "gia%03d.aig", Counter++ );
//Gia_WriteAiger( pAig, Buffer, 0, 0 );
//printf( "Dumpted slice into file \"%s\".\n", Buffer );
// reset the manager
if ( pPat )
{
......@@ -501,6 +512,8 @@ void Cec_ManSatSolve( Cec_ManPat_t * pPat, Gia_Man_t * pAig, Cec_ParSat_t * pPar
pObj->fMark1 = 1;
continue;
}
//printf( "Output %6d : ", i );
Bar_ProgressUpdate( pProgress, i, "SAT..." );
status = Cec_ManSatCheckNode( p, pObj );
pObj->fMark0 = (status == 0);
......
src/aig/gia/gia.h
......@@ -24,7 +24,7 @@
////////////////////////////////////////////////////////////////////////
/// INCLUDES ///
////////////////////////////////////////////////////////////////////////
#include "aig.h"
////////////////////////////////////////////////////////////////////////
......@@ -303,6 +303,8 @@ static inline int Gia_XsimAndCond( int Value0, int fCompl0, int Value1, int fCom
for ( i = 1; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )
#define Gia_ManForEachObjVec( vVec, p, pObj, i ) \
for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )
#define Gia_ManForEachObjVecLit( vVec, p, pObj, fCompl, i ) \
for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Gia_Lit2Var(Vec_IntEntry(vVec,i)))) && (((fCompl) = Gia_LitIsCompl(Vec_IntEntry(vVec,i))),1); i++ )
#define Gia_ManForEachAnd( p, pObj, i ) \
for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsAnd(pObj) ) {} else
#define Gia_ManForEachCi( p, pObj, i ) \
......@@ -373,11 +375,12 @@ extern void Gia_ManHashStart( Gia_Man_t * p );
extern void Gia_ManHashStop( Gia_Man_t * p );
extern int Gia_ManHashAnd( Gia_Man_t * p, int iLit0, int iLit1 );
extern int Gia_ManHashXor( Gia_Man_t * p, int iLit0, int iLit1 );
extern int Gia_ManHashMux( Gia_Man_t * p, int iCtrl, int iData1, int iData0 );
extern int Gia_ManHashAndTry( Gia_Man_t * p, int iLit0, int iLit1 );
extern Gia_Man_t * Gia_ManRehash( Gia_Man_t * p );
/*=== giaLogic.c ===========================================================*/
extern void Gia_ManTestDistance( Gia_Man_t * p );
extern void Gia_ManSolveProblem( Gia_Man_t * pGia, int nDims, int nSols );
extern void Gia_ManSolveProblem( Gia_Man_t * pGia, int nDims, int nSols, int fCluster, int fDump, int fVerbose );
/*=== giaMan.c ===========================================================*/
extern Gia_Man_t * Gia_ManStart( int nObjsMax );
extern void Gia_ManStop( Gia_Man_t * p );
......
src/aig/gia/giaDup.c
......@@ -417,39 +417,67 @@ Gia_Man_t * Gia_ManDupCofactored( Gia_Man_t * p, int iVar )
{
Gia_Man_t * pNew, * pTemp;
Gia_Obj_t * pObj, * pPivot;
int i;
assert( Gia_ManRegNum(p) == 0 );
assert( iVar < Gia_ManObjNum(p) );
int i, iCofVar = -1;
if ( !(iVar > 0 && iVar < Gia_ManObjNum(p)) )
{
printf( "Gia_ManDupCofactored(): Variable %d is out of range (%d; %d).\n", iVar, 0, Gia_ManObjNum(p) );
return NULL;
}
// find the cofactoring variable
pPivot = Gia_ManObj( p, iVar );
if ( !(Gia_ObjIsCi(pPivot) || Gia_ObjIsAnd(pPivot)) )
{
printf( "Gia_ManDupCofactored(): Variable %d should be a CI or an AND node.\n", iVar );
return NULL;
}
// assert( Gia_ManRegNum(p) == 0 );
pNew = Gia_ManStart( Gia_ManObjNum(p) );
pNew->pName = Aig_UtilStrsav( p->pName );
Gia_ManHashAlloc( pNew );
Gia_ManConst0(p)->Value = 0;
// compute negative cofactor
Gia_ManForEachCi( p, pObj, i )
{
pObj->Value = Gia_ManAppendCi(pNew);
// find the cofactoring variable
pPivot = Gia_ManObj(p, iVar);
// compute the negative cofactor
if ( Gia_ObjIsCi(pPivot) )
pPivot->Value = Gia_Var2Lit( 0, 0 );
if ( pObj == pPivot )
{
iCofVar = pObj->Value;
pObj->Value = Gia_Var2Lit( 0, 0 );
}
}
Gia_ManForEachAnd( p, pObj, i )
{
pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
if ( pObj == pPivot )
pPivot->Value = Gia_Var2Lit( 0, 0 );
{
iCofVar = pObj->Value;
pObj->Value = Gia_Var2Lit( 0, 0 );
}
}
Gia_ManForEachCo( p, pObj, i )
pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
pObj->Value = Gia_ObjFanin0Copy(pObj);
// compute the positive cofactor
if ( Gia_ObjIsCi(pPivot) )
pPivot->Value = Gia_Var2Lit( 0, 1 );
Gia_ManForEachCi( p, pObj, i )
{
pObj->Value = Gia_Var2Lit( Gia_ObjId(pNew, Gia_ManCi(pNew, i)), 0 );
if ( pObj == pPivot )
pObj->Value = Gia_Var2Lit( 0, 1 );
}
Gia_ManForEachAnd( p, pObj, i )
{
pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
if ( pObj == pPivot )
pPivot->Value = Gia_Var2Lit( 0, 1 );
pObj->Value = Gia_Var2Lit( 0, 1 );
}
// create MUXes
assert( iCofVar > 0 );
Gia_ManForEachCo( p, pObj, i )
pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
{
if ( pObj->Value == (unsigned)Gia_ObjFanin0Copy(pObj) )
pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
else
pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashMux(pNew, iCofVar, Gia_ObjFanin0Copy(pObj), pObj->Value) );
}
Gia_ManHashStop( pNew );
Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
// rehash the result
......
src/aig/gia/giaForce.c
......@@ -42,7 +42,7 @@ struct For_Man_t_
Gia_Man_t * pGia; // the original AIG manager
int nObjs; // the number of objects
int iObj; // the last added object
int * pPlace; // Placeing of objects
int * pPlace; // coordinates of objects
int * piNext; // array of next pointers
int * piRoot; // array of root pointers
float * plEdge; // edge coordinates
......@@ -413,7 +413,7 @@ void For_ManSortObjects( For_Man_t * p )
p->piNext[i] = p->piRoot[iPlace];
p->piRoot[iPlace] = i;
}
// recostruct the order
// reconstruct the order
p->iObj = 0;
pPrev = NULL;
vArray = Vec_PtrAlloc( 100 );
......
src/aig/gia/giaGlitch.c
......@@ -630,23 +630,38 @@ static inline unsigned Gli_ManUpdateRandomInput( unsigned uInfo, float PiTransPr
SeeAlso []
***********************************************************************/
static inline void Gli_ManSimulateSeqOne( Gli_Man_t * p, float PiTransProb )
void Gli_ManSimulateSeqPref( Gli_Man_t * p, int nPref )
{
Gli_Obj_t * pObj, * pObjRi, * pObjRo;
int i;
int i, f;
// initialize simulation data
Gli_ManForEachPi( p, pObj, i )
pObj->uSimInfo = Gli_ManUpdateRandomInput( pObj->uSimInfo, PiTransProb );
Gli_ManForEachNode( p, pObj, i )
pObj->uSimInfo = Gli_ManSimulateSeqNode( p, pObj );
Gli_ManForEachRi( p, pObj, i )
pObj->uSimInfo = Gli_ObjFanin(pObj, 0)->uSimInfo;
Gli_ManForEachRiRo( p, pObjRi, pObjRo, i )
pObjRo->uSimInfo = pObjRi->uSimInfo;
pObj->uSimInfo = Gli_ManUpdateRandomInput( pObj->uSimInfo, 0.5 );
Gli_ManForEachRo( p, pObj, i )
pObj->uSimInfo = 0;
for ( f = 0; f < nPref; f++ )
{
// simulate one frame
Gli_ManForEachNode( p, pObj, i )
pObj->uSimInfo = Gli_ManSimulateSeqNode( p, pObj );
Gli_ManForEachRi( p, pObj, i )
pObj->uSimInfo = Gli_ObjFanin(pObj, 0)->uSimInfo;
// initialize the next frame
Gli_ManForEachPi( p, pObj, i )
pObj->uSimInfo = Gli_ManUpdateRandomInput( pObj->uSimInfo, 0.5 );
Gli_ManForEachRiRo( p, pObjRi, pObjRo, i )
pObjRo->uSimInfo = pObjRi->uSimInfo;
}
// save simulation data after nPref timeframes
if ( p->pSimInfoPrev == NULL )
p->pSimInfoPrev = ABC_ALLOC( unsigned, Gli_ManCiNum(p) );
Gli_ManForEachCi( p, pObj, i )
p->pSimInfoPrev[i] = pObj->uSimInfo;
}
/**Function*************************************************************
Synopsis [Simulates sequential network randomly for the given number of frames.]
Synopsis [Initialized object values to be one pattern in the saved data.]
Description []
......@@ -655,19 +670,19 @@ static inline void Gli_ManSimulateSeqOne( Gli_Man_t * p, float PiTransProb )
SeeAlso []
***********************************************************************/
static inline void Gli_ManSaveCiInfo( Gli_Man_t * p )
void Gli_ManSetDataSaved( Gli_Man_t * p, int iBit )
{
Gli_Obj_t * pObj;
int i;
if ( p->pSimInfoPrev == NULL )
p->pSimInfoPrev = ABC_ALLOC( unsigned, Gli_ManCiNum(p) );
Gli_ManForEachCi( p, pObj, i )
p->pSimInfoPrev[i] = pObj->uSimInfo;
pObj->fPhase = pObj->fPhase2 = ((p->pSimInfoPrev[i] >> iBit) & 1);
Gli_ManForEachNode( p, pObj, i )
pObj->fPhase = pObj->fPhase2 = Gli_NodeComputeValue( pObj );
}
/**Function*************************************************************
Synopsis [Simulates sequential network randomly for the given number of frames.]
Synopsis [Sets random info at the PIs and collects changed PIs.]
Description []
......@@ -676,14 +691,37 @@ static inline void Gli_ManSaveCiInfo( Gli_Man_t * p )
SeeAlso []
***********************************************************************/
void Gli_ManSimulateSeqPref( Gli_Man_t * p, int nPref )
void Gli_ManSetPiRandomSeq( Gli_Man_t * p, float PiTransProb )
{
Gli_Obj_t * pObj;
int i, f;
Gli_ManForEachRo( p, pObj, i )
pObj->uSimInfo = 0;
for ( f = 0; f < nPref; f++ )
Gli_ManSimulateSeqOne( p, 0.5 );
Gli_Obj_t * pObj, * pObjRi;
float Multi = 1.0 / (1 << 16);
int i;
assert( 0.0 < PiTransProb && PiTransProb < 1.0 );
// transfer data to the COs
Gli_ManForEachCo( p, pObj, i )
pObj->fPhase = pObj->fPhase2 = Gli_ObjFanin(pObj, 0)->fPhase;
// set changed PIs
Vec_IntClear( p->vCisChanged );
Gli_ManForEachPi( p, pObj, i )
if ( Multi * (Aig_ManRandom(0) & 0xffff) < PiTransProb )
{
Vec_IntPush( p->vCisChanged, pObj->Handle );
pObj->fPhase ^= 1;
pObj->fPhase2 ^= 1;
pObj->nSwitches++;
pObj->nGlitches++;
}
// set changed ROs
Gli_ManForEachRiRo( p, pObjRi, pObj, i )
if ( pObjRi->fPhase != pObj->fPhase )
{
Vec_IntPush( p->vCisChanged, pObj->Handle );
pObj->fPhase ^= 1;
pObj->fPhase2 ^= 1;
pObj->nSwitches++;
pObj->nGlitches++;
}
}
/**Function*************************************************************
......@@ -714,14 +752,14 @@ void Gli_ManSwitchesAndGlitches( Gli_Man_t * p, int nPatterns, float PiTransProb
}
else
{
int nIters = Aig_BitWordNum(nPatterns);
Gli_ManSimulateSeqPref( p, 16 );
for ( k = Aig_BitWordNum(nPatterns) - 1; k >= 0; k-- )
for ( i = 0; i < 32; i++ )
{
Gli_ManSaveCiInfo( p );
Gli_ManSimulateSeqOne( p, PiTransProb );
for ( i = 0; i < 32; i++ )
Gli_ManSetDataSaved( p, i );
for ( k = 0; k < nIters; k++ )
{
Gli_ManSetPiFromSaved( p, i );
Gli_ManSetPiRandomSeq( p, PiTransProb );
Gli_ManSwitching( p );
Gli_ManGlitching( p );
// Gli_ManVerify( p );
......
src/aig/gia/giaHash.c
......@@ -509,6 +509,24 @@ int Gia_ManHashXor( Gia_Man_t * p, int iLit0, int iLit1 )
SeeAlso []
***********************************************************************/
int Gia_ManHashMux( Gia_Man_t * p, int iCtrl, int iData1, int iData0 )
{
int iTemp0 = Gia_ManHashAnd( p, Gia_LitNot(iCtrl), iData0 );
int iTemp1 = Gia_ManHashAnd( p, iCtrl, iData1 );
return Gia_LitNotCond( Gia_ManHashAnd( p, Gia_LitNot(iTemp0), Gia_LitNot(iTemp1) ), 1 );
}
/**Function*************************************************************
Synopsis [Rehashes AIG with mapping.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Gia_Man_t * Gia_ManRehash( Gia_Man_t * p )
{
Gia_Man_t * pNew;
......
src/aig/gia/giaSort.c
......@@ -59,13 +59,13 @@ static void sort_rec(int* array, int size, int(*comp)(const void *, const void *
if (size <= 15)
selectionsort(array, size, comp);
else{
int * pivot = array + size/2;
int pivot = array[size/2];
int tmp;
int i = -1;
int j = size;
for(;;){
do i++; while(comp(array + i, pivot));
do j--; while(comp(pivot, array + j));
do i++; while(comp(array + i, &pivot));
do j--; while(comp(&pivot, array + j));
if (i >= j) break;
tmp = array[i]; array[i] = array[j]; array[j] = tmp;
}
......@@ -79,6 +79,65 @@ void minisat_sort(int* array, int size, int(*comp)(const void *, const void *))
}
/**Function*************************************************************
Synopsis [This is implementation of qsort in MiniSat.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void selectionsort2(int* array, int size)
{
int i, j, best_i;
int tmp;
for (i = 0; i < size-1; i++){
best_i = i;
for (j = i+1; j < size; j++){
if (array[j] < array[best_i])
best_i = j;
}
tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
}
}
static void sort_rec2(int* array, int size)
{
if (size <= 15)
selectionsort2(array, size);
else{
int pivot = array[size/2];
int tmp;
int i = -1;
int j = size;
for(;;){
do i++; while(array[i] < pivot);
do j--; while(pivot < array[j]);
if (i >= j) break;
tmp = array[i]; array[i] = array[j]; array[j] = tmp;
}
sort_rec2(array , i );
sort_rec2(&array[i], size-i);
}
}
void minisat_sort2(int* array, int size)
{
sort_rec2(array,size);
}
/**Function*************************************************************
Synopsis [This is implementation of qsort in MiniSat.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int * Gia_SortGetTest( int nSize )
{
int i, * pArray;
......@@ -96,10 +155,11 @@ void Gia_SortVerifySorted( int * pArray, int nSize )
}
void Gia_SortTest()
{
int nSize = 1000000;
int nSize = 100000000;
int * pArray;
int clk = clock();
printf( "Sorting %d integers\n", nSize );
pArray = Gia_SortGetTest( nSize );
clk = clock();
qsort( pArray, nSize, 4, (int (*)(const void *, const void *)) num_cmp1 );
......@@ -113,8 +173,91 @@ clk = clock();
ABC_PRT( "minisat", clock() - clk );
Gia_SortVerifySorted( pArray, nSize );
ABC_FREE( pArray );
pArray = Gia_SortGetTest( nSize );
clk = clock();
minisat_sort2( pArray, nSize );
ABC_PRT( "minisat with inlined comparison", clock() - clk );
Gia_SortVerifySorted( pArray, nSize );
ABC_FREE( pArray );
}
/**Function*************************************************************
Synopsis [This is implementation of qsort in MiniSat.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void selectionsort3(float* array, int* perm, int size)
{
float tmpf;
int tmpi;
int i, j, best_i;
for (i = 0; i < size-1; i++){
best_i = i;
for (j = i+1; j < size; j++){
if (array[j] < array[best_i])
best_i = j;
}
tmpf = array[i]; array[i] = array[best_i]; array[best_i] = tmpf;
tmpi = perm[i]; perm[i] = perm[best_i]; perm[best_i] = tmpi;
}
}
static void sort_rec3(float* array, int* perm, int size)
{
if (size <= 15)
selectionsort3(array, perm, size);
else{
float pivot = array[size/2];
float tmpf;
int tmpi;
int i = -1;
int j = size;
for(;;){
do i++; while(array[i] < pivot);
do j--; while(pivot < array[j]);
if (i >= j) break;
tmpf = array[i]; array[i] = array[j]; array[j] = tmpf;
tmpi = perm[i]; perm[i] = perm[j]; perm[j] = tmpi;
}
sort_rec3(array , perm, i );
sort_rec3(&array[i], &perm[i], size-i);
}
}
void minisat_sort3(float* array, int* perm, int size)
{
sort_rec3(array, perm, size);
}
/**Function*************************************************************
Synopsis [Sorts the array of floating point numbers.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int * Gia_SortFloats( float * pArray, int nSize )
{
int i, * pPerm;
pPerm = ABC_ALLOC( int, nSize );
for ( i = 0; i < nSize; i++ )
pPerm[i] = i;
minisat_sort3( pArray, pPerm, nSize );
// for ( i = 1; i < nSize; i++ )
// assert( pArray[i-1] <= pArray[i] );
return pPerm;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
......
src/aig/gia/module.make
......@@ -14,6 +14,7 @@ SRC += src/aig/gia/gia.c \
src/aig/gia/giaMan.c \
src/aig/gia/giaScl.c \
src/aig/gia/giaSim.c \
src/aig/gia/giaSort.c \
src/aig/gia/giaSwitch.c \
src/aig/gia/giaTsim.c \
src/aig/gia/giaUtil.c
src/aig/ssw/sswCore.c
......@@ -50,7 +50,7 @@ void Ssw_ManSetDefaultParams( Ssw_Pars_t * p )
p->nBTLimit = 1000; // conflict limit at a node
p->nBTLimitGlobal = 5000000; // conflict limit for all runs
p->nMinDomSize = 100; // min clock domain considered for optimization
p->nItersStop = 0; // stop after the given number of iterations
p->nItersStop = -1; // stop after the given number of iterations
p->nResimDelta = 1000; // the internal of nodes to resimulate
p->fPolarFlip = 0; // uses polarity adjustment
p->fLatchCorr = 0; // performs register correspondence
......@@ -199,7 +199,7 @@ clk = clock();
if ( !RetValue )
break;
if ( p->pPars->nItersStop && p->pPars->nItersStop == nIter )
if ( p->pPars->nItersStop >= 0 && p->pPars->nItersStop == nIter )
{
Aig_Man_t * pSRed = Ssw_SpeculativeReduction( p );
Aig_ManDumpBlif( pSRed, "srm.blif", NULL, NULL );
......
src/base/abci/abc.c
......@@ -14501,7 +14501,7 @@ usage:
fprintf( pErr, "\t-L num : max number of levels to consider (0=all) [default = %d]\n", pPars->nMaxLevs );
fprintf( pErr, "\t-N num : number of last POs treated as constraints (0=none) [default = %d]\n", pPars->nConstrs );
fprintf( pErr, "\t-S num : additional simulation frames for c-examples (0=none) [default = %d]\n", pPars->nFramesAddSim );
fprintf( pErr, "\t-I num : iteration number to stop and output SR-model (0=none) [default = %d]\n", pPars->nItersStop );
fprintf( pErr, "\t-I num : iteration number to stop and output SR-model (-1=none) [default = %d]\n", pPars->nItersStop );
fprintf( pErr, "\t-V num : min var num needed to recycle the SAT solver [default = %d]\n", pPars->nSatVarMax2 );
fprintf( pErr, "\t-M num : min call num needed to recycle the SAT solver [default = %d]\n", pPars->nRecycleCalls2 );
fprintf( pErr, "\t-p : toggle alighning polarity of SAT variables [default = %s]\n", pPars->fPolarFlip? "yes": "no" );
......@@ -22365,6 +22365,12 @@ int Abc_CommandAbc9Cof( Abc_Frame_t * pAbc, int argc, char ** argv )
return 1;
}
pAbc->pAig = Gia_ManDupCofactored( pTemp = pAbc->pAig, iVar );
if ( pAbc->pAig == NULL )
{
pAbc->pAig = pTemp;
printf( "Abc_CommandAbc9Cof(): Transformation has failed.\n" );
return 1;
}
Gia_ManStop( pTemp );
return 0;
......@@ -23017,12 +23023,36 @@ usage:
***********************************************************************/
int Abc_CommandAbc9Embed( Abc_Frame_t * pAbc, int argc, char ** argv )
{
int nDims = 30;
int fCluster = 0;
int fDump = 0;
int fVerbose = 0;
int c;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF )
while ( ( c = Extra_UtilGetopt( argc, argv, "Ddcvh" ) ) != EOF )
{
switch ( c )
{
case 'D':
if ( globalUtilOptind >= argc )
{
fprintf( stdout, "Command line switch \"-D\" should be followed by an integer.\n" );
goto usage;
}
nDims = atoi(argv[globalUtilOptind]);
globalUtilOptind++;
if ( nDims < 0 )
goto usage;
break;
case 'c':
fCluster ^= 1;
break;
case 'd':
fDump ^= 1;
break;
case 'v':
fVerbose ^= 1;
break;
case 'h':
goto usage;
default:
......@@ -23034,15 +23064,19 @@ int Abc_CommandAbc9Embed( Abc_Frame_t * pAbc, int argc, char ** argv )
printf( "Abc_CommandAbc9Test(): There is no AIG.\n" );
return 1;
}
Gia_ManSolveProblem( pAbc->pAig, 30, 2 );
Gia_ManSolveProblem( pAbc->pAig, nDims, 2, fCluster, fDump, fVerbose );
return 0;
usage:
fprintf( stdout, "usage: &embed [-h]\n" );
fprintf( stdout, "\t fast placement based on the technique introduced by\n" );
fprintf( stdout, "\t D. Harel and Y. Koren, \"Graph drawing by high-dimensional\n" );
fprintf( stdout, "\t embedding\", J. Graph Algs & Apps, Vol 8(2), pp. 195-217 (2004)\n" );
fprintf( stdout, "\t-h : print the command usage\n");
fprintf( stdout, "usage: &embed [-D num] [-dcvh]\n" );
fprintf( stdout, "\t fast placement based on high-dimensional embedding from\n" );
fprintf( stdout, "\t D. Harel and Y. Koren, \"Graph drawing by high-dimensional\n" );
fprintf( stdout, "\t embedding\", J. Graph Algs & Apps, 2004, Vol 8(2), pp. 195-217\n" );
fprintf( stdout, "\t-D num : the number of dimensions for embedding [default = %d]\n", nDims );
fprintf( stdout, "\t-d : toggle dumping placement into a Gnuplot file [default = %s]\n", fDump? "yes":"no");
fprintf( stdout, "\t-c : toggle clustered representation [default = %s]\n", fCluster? "yes":"no");
fprintf( stdout, "\t-v : toggle verbose output [default = %s]\n", fVerbose? "yes":"no");
fprintf( stdout, "\t-h : print the command usage\n");
return 1;
}
......@@ -23060,6 +23094,8 @@ usage:
int Abc_CommandAbc9Test( Abc_Frame_t * pAbc, int argc, char ** argv )
{
int c;
extern void Gia_SatSolveTest( Gia_Man_t * p );
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF )
{
......@@ -23081,7 +23117,8 @@ int Abc_CommandAbc9Test( Abc_Frame_t * pAbc, int argc, char ** argv )
// Sat_ManTest( pAbc->pAig, Gia_ManCo(pAbc->pAig, 0), 0 );
// Gia_ManTestDistance( pAbc->pAig );
// For_ManExperiment( pAbc->pAig );
Gia_ManSolveProblem( pAbc->pAig, 30, 2 );
Gia_ManSolveProblem( pAbc->pAig, 30, 2, 1, 0, 1 );
// Gia_SatSolveTest( pAbc->pAig );
return 0;
usage:
......
src/base/abci/abcFxu.c
......@@ -192,7 +192,7 @@ void Abc_NtkFxuFreeInfo( Fxu_Data_t * p )
/**Function*************************************************************
Synopsis [Recostructs the network after FX.]
Synopsis [Reconstructs the network after FX.]
Description []
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment