ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
acbMfs.c
Go to the documentation of this file.
1
20
21#include "acb.h"
22#include "bool/kit/kit.h"
23#include "sat/bsat/satSolver.h"
24#include "sat/cnf/cnf.h"
25#include "misc/util/utilTruth.h"
26#include "acbPar.h"
27
28ABC_NAMESPACE_IMPL_START
29
33
34static inline int Acb_ObjIsDelayCriticalFanin( Acb_Ntk_t * p, int i, int f ) { return !Acb_ObjIsCi(p, f) && Acb_ObjLevelR(p, i) + Acb_ObjLevelD(p, f) == p->LevelMax; }
35static inline int Acb_ObjIsAreaCritical( Acb_Ntk_t * p, int f ) { return !Acb_ObjIsCi(p, f) && Acb_ObjFanoutNum(p, f) == 1; }
36static inline int Acb_ObjIsCritical( Acb_Ntk_t * p, int i, int f, int fDel ) { return fDel ? Acb_ObjIsDelayCriticalFanin(p, i, f) : Acb_ObjIsAreaCritical(p, f); }
37
41
53int Acb_DeriveCnfFromTruth( word Truth, int nVars, Vec_Int_t * vCover, Vec_Str_t * vCnf )
54{
55 Vec_StrClear( vCnf );
56 if ( Truth == 0 || ~Truth == 0 )
57 {
58// assert( nVars == 0 );
59 Vec_StrPush( vCnf, (char)(Truth == 0) );
60 Vec_StrPush( vCnf, (char)-1 );
61 return 1;
62 }
63 else
64 {
65 int i, k, c, RetValue, Literal, Cube, nCubes = 0;
66 assert( nVars > 0 );
67 for ( c = 0; c < 2; c ++ )
68 {
69 Truth = c ? ~Truth : Truth;
70 RetValue = Kit_TruthIsop( (unsigned *)&Truth, nVars, vCover, 0 );
71 assert( RetValue == 0 );
72 nCubes += Vec_IntSize( vCover );
73 Vec_IntForEachEntry( vCover, Cube, i )
74 {
75 for ( k = 0; k < nVars; k++ )
76 {
77 Literal = 3 & (Cube >> (k << 1));
78 if ( Literal == 1 ) // '0' -> pos lit
79 Vec_StrPush( vCnf, (char)Abc_Var2Lit(k, 0) );
80 else if ( Literal == 2 ) // '1' -> neg lit
81 Vec_StrPush( vCnf, (char)Abc_Var2Lit(k, 1) );
82 else if ( Literal != 0 )
83 assert( 0 );
84 }
85 Vec_StrPush( vCnf, (char)Abc_Var2Lit(nVars, c) );
86 Vec_StrPush( vCnf, (char)-1 );
87 }
88 }
89 return nCubes;
90 }
91}
92
93void Acb_DeriveCnfForWindowOne( Acb_Ntk_t * p, int iObj )
94{
95 Vec_Wec_t * vCnfs = &p->vCnfs;
96 Vec_Str_t * vCnfBase = Acb_ObjCnfs( p, iObj );
97 assert( Vec_StrSize(vCnfBase) == 0 ); // unassigned
98 assert( Vec_WecSize(vCnfs) == Acb_NtkObjNumMax(p) );
99 Acb_DeriveCnfFromTruth( Acb_ObjTruth(p, iObj), Acb_ObjFaninNum(p, iObj), &p->vCover, &p->vCnf );
100 Vec_StrGrow( vCnfBase, Vec_StrSize(&p->vCnf) );
101 memcpy( Vec_StrArray(vCnfBase), Vec_StrArray(&p->vCnf), (size_t)Vec_StrSize(&p->vCnf) );
102 vCnfBase->nSize = Vec_StrSize(&p->vCnf);
103}
104Vec_Wec_t * Acb_DeriveCnfForWindow( Acb_Ntk_t * p, Vec_Int_t * vWin, int PivotVar )
105{
106 Vec_Wec_t * vCnfs = &p->vCnfs;
107 Vec_Str_t * vCnfBase; int i, iObj;
108 assert( Vec_WecSize(vCnfs) == Acb_NtkObjNumMax(p) );
109 Vec_IntForEachEntry( vWin, iObj, i )
110 {
111 if ( Abc_LitIsCompl(iObj) && i < PivotVar )
112 continue;
113 iObj = Abc_Lit2Var(iObj);
114 vCnfBase = Acb_ObjCnfs( p, iObj );
115 if ( Vec_StrSize(vCnfBase) > 0 )
116 continue;
117 Acb_DeriveCnfForWindowOne( p, iObj );
118 }
119 return vCnfs;
120}
121
139void Acb_TranslateCnf( Vec_Int_t * vClas, Vec_Int_t * vLits, Vec_Str_t * vCnf, Vec_Int_t * vSatVars, int iPivotVar )
140{
141 signed char Entry;
142 int i, Lit;
143 Vec_StrForEachEntry( vCnf, Entry, i )
144 {
145 if ( (int)Entry == -1 )
146 {
147 Vec_IntPush( vClas, Vec_IntSize(vLits) );
148 continue;
149 }
150 Lit = Abc_Lit2LitV( Vec_IntArray(vSatVars), (int)Entry );
151 Lit = Abc_LitNotCond( Lit, Abc_Lit2Var(Lit) == iPivotVar );
152 Vec_IntPush( vLits, Lit );
153 }
154}
155int Acb_NtkCountRoots( Vec_Int_t * vWinObjs, int PivotVar )
156{
157 int i, iObjLit, nRoots = 0;
158 Vec_IntForEachEntryStart( vWinObjs, iObjLit, i, PivotVar + 1 )
159 nRoots += Abc_LitIsCompl(iObjLit);
160 return nRoots;
161}
162void Acb_DeriveCnfForNode( Acb_Ntk_t * p, int iObj, sat_solver * pSat, int OutVar )
163{
164 Vec_Wec_t * vCnfs = &p->vCnfs;
165 Vec_Int_t * vFaninVars = &p->vCover;
166 Vec_Int_t * vClas = Vec_IntAlloc( 100 );
167 Vec_Int_t * vLits = Vec_IntAlloc( 100 );
168 int k, iFanin, * pFanins, Prev, This;
169 // collect SAT variables
170 Vec_IntClear( vFaninVars );
171 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
172 {
173 assert( Acb_ObjFunc(p, iFanin) >= 0 );
174 Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iFanin) );
175 }
176 Vec_IntPush( vFaninVars, OutVar );
177 // derive CNF for the node
178 Acb_TranslateCnf( vClas, vLits, (Vec_Str_t *)Vec_WecEntry(vCnfs, iObj), vFaninVars, -1 );
179 // add clauses
180 Prev = 0;
181 Vec_IntForEachEntry( vClas, This, k )
182 {
183 if ( !sat_solver_addclause( pSat, Vec_IntArray(vLits) + Prev, Vec_IntArray(vLits) + This ) )
184 printf( "Error: SAT solver became UNSAT at a wrong place (while adding new CNF).\n" );
185 Prev = This;
186 }
187 Vec_IntFree( vClas );
188 Vec_IntFree( vLits );
189}
190Cnf_Dat_t * Acb_NtkWindow2Cnf( Acb_Ntk_t * p, Vec_Int_t * vWinObjs, int Pivot )
191{
192 Cnf_Dat_t * pCnf;
193 Vec_Int_t * vFaninVars = Vec_IntAlloc( 8 );
194 int PivotVar = Vec_IntFind(vWinObjs, Abc_Var2Lit(Pivot, 0));
195 int nRoots = Acb_NtkCountRoots(vWinObjs, PivotVar);
196 int TfoStart = PivotVar + 1;
197 int nTfoSize = Vec_IntSize(vWinObjs) - TfoStart;
198 int nVarsAll = Vec_IntSize(vWinObjs) + nTfoSize + nRoots;
199 int i, k, iObj, iObjLit, iFanin, * pFanins, Entry;
200 Vec_Wec_t * vCnfs = Acb_DeriveCnfForWindow( p, vWinObjs, PivotVar );
201 Vec_Int_t * vClas = Vec_IntAlloc( 100 );
202 Vec_Int_t * vLits = Vec_IntAlloc( 1000 );
203 // mark new SAT variables
204 Vec_IntForEachEntry( vWinObjs, iObj, i )
205 Acb_ObjSetFunc( p, Abc_Lit2Var(iObj), i );
206 // add clauses for all nodes
207 Vec_IntPush( vClas, Vec_IntSize(vLits) );
208 Vec_IntForEachEntry( vWinObjs, iObjLit, i )
209 {
210 if ( Abc_LitIsCompl(iObjLit) && i < PivotVar )
211 continue;
212 iObj = Abc_Lit2Var(iObjLit);
213 assert( !Acb_ObjIsCio(p, iObj) );
214 // collect SAT variables
215 Vec_IntClear( vFaninVars );
216 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
217 Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iFanin) );
218 Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iObj) );
219 // derive CNF for the node
220 Acb_TranslateCnf( vClas, vLits, (Vec_Str_t *)Vec_WecEntry(vCnfs, iObj), vFaninVars, -1 );
221 }
222 // add second clauses for the TFO
223 Vec_IntForEachEntryStart( vWinObjs, iObjLit, i, TfoStart )
224 {
225 iObj = Abc_Lit2Var(iObjLit);
226 assert( !Acb_ObjIsCio(p, iObj) );
227 // collect SAT variables
228 Vec_IntClear( vFaninVars );
229 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
230 Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iFanin) + (Acb_ObjFunc(p, iFanin) > PivotVar) * nTfoSize );
231 Vec_IntPush( vFaninVars, Acb_ObjFunc(p, iObj) + nTfoSize );
232 // derive CNF for the node
233 Acb_TranslateCnf( vClas, vLits, (Vec_Str_t *)Vec_WecEntry(vCnfs, iObj), vFaninVars, PivotVar );
234 }
235 if ( nRoots > 0 )
236 {
237 // create XOR clauses for the roots
238 int nVars = Vec_IntSize(vWinObjs) + nTfoSize;
239 Vec_IntClear( vFaninVars );
240 Vec_IntForEachEntryStart( vWinObjs, iObjLit, i, TfoStart )
241 {
242 if ( !Abc_LitIsCompl(iObjLit) )
243 continue;
244 iObj = Abc_Lit2Var(iObjLit);
245 // add clauses
246 Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 1), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 0), Abc_Var2Lit(nVars, 0) );
247 Vec_IntPush( vClas, Vec_IntSize(vLits) );
248 Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 0), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 1), Abc_Var2Lit(nVars, 0) );
249 Vec_IntPush( vClas, Vec_IntSize(vLits) );
250 Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 0), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 0), Abc_Var2Lit(nVars, 1) );
251 Vec_IntPush( vClas, Vec_IntSize(vLits) );
252 Vec_IntPushThree( vLits, Abc_Var2Lit(Acb_ObjFunc(p, iObj), 1), Abc_Var2Lit(Acb_ObjFunc(p, iObj) + nTfoSize, 1), Abc_Var2Lit(nVars, 1) );
253 Vec_IntPush( vClas, Vec_IntSize(vLits) );
254 Vec_IntPush( vFaninVars, Abc_Var2Lit(nVars++, 0) );
255 }
256 Vec_IntAppend( vLits, vFaninVars );
257 Vec_IntPush( vClas, Vec_IntSize(vLits) );
258 assert( nRoots == Vec_IntSize(vFaninVars) );
259 assert( nVars == nVarsAll );
260 }
261 Vec_IntFree( vFaninVars );
262 // create CNF structure
263 pCnf = ABC_CALLOC( Cnf_Dat_t, 1 );
264 pCnf->nVars = nVarsAll;
265 pCnf->nClauses = Vec_IntSize(vClas)-1;
266 pCnf->nLiterals = Vec_IntSize(vLits);
267 pCnf->pClauses = ABC_ALLOC( int *, Vec_IntSize(vClas) );
268 pCnf->pClauses[0] = Vec_IntReleaseArray(vLits);
269 Vec_IntForEachEntry( vClas, Entry, i )
270 pCnf->pClauses[i] = pCnf->pClauses[0] + Entry;
271 // cleanup
272 Vec_IntFree( vClas );
273 Vec_IntFree( vLits );
274 //Cnf_DataPrint( pCnf, 1 );
275 return pCnf;
276}
277void Acb_NtkWindowUndo( Acb_Ntk_t * p, Vec_Int_t * vWin )
278{
279 int i, iObj;
280 Vec_IntForEachEntry( vWin, iObj, i )
281 {
282 assert( Vec_IntEntry(&p->vObjFunc, Abc_Lit2Var(iObj)) != -1 );
283 Vec_IntWriteEntry( &p->vObjFunc, Abc_Lit2Var(iObj), -1 );
284 }
285}
286
298int Acb_NtkWindow2Solver( sat_solver * pSat, Cnf_Dat_t * pCnf, Vec_Int_t * vFlip, int PivotVar, int nDivs, int nTimes )
299{
300 int n, i, RetValue, Test = pCnf->pClauses[0][0];
301 int nGroups = nTimes <= 2 ? nTimes-1 : 2;
302 int nRounds = nTimes <= 2 ? nTimes-1 : nTimes;
303 assert( sat_solver_nvars(pSat) == 0 );
304 sat_solver_setnvars( pSat, nTimes * pCnf->nVars + nGroups * nDivs + 2 );
305 assert( nTimes == 1 || nTimes == 2 || nTimes == 6 );
306 for ( n = 0; n < nTimes; n++ )
307 {
308 if ( n & 1 )
309 Cnf_DataLiftAndFlipLits( pCnf, -pCnf->nVars, vFlip );
310 for ( i = 0; i < pCnf->nClauses; i++ )
311 if ( !sat_solver_addclause( pSat, pCnf->pClauses[i], pCnf->pClauses[i+1] ) )
312 printf( "Error: SAT solver became UNSAT at a wrong place.\n" );
313 if ( n & 1 )
314 Cnf_DataLiftAndFlipLits( pCnf, pCnf->nVars, vFlip );
315 if ( n < nTimes - 1 )
316 Cnf_DataLift( pCnf, pCnf->nVars );
317 else if ( n ) // if ( n == nTimes - 1 )
318 Cnf_DataLift( pCnf, -(nTimes - 1) * pCnf->nVars );
319 }
320 assert( Test == pCnf->pClauses[0][0] );
321 // add conditional buffers
322 for ( n = 0; n < nRounds; n++ )
323 {
324 int BaseA = n * pCnf->nVars;
325 int BaseB = ((n + 1) % nTimes) * pCnf->nVars;
326 int BaseC = nTimes * pCnf->nVars + (n & 1) * nDivs;
327 for ( i = 0; i < nDivs; i++ )
328 sat_solver_add_buffer_enable( pSat, BaseA + i, BaseB + i, BaseC + i, 0 );
329 }
330 // finalize
331 RetValue = sat_solver_simplify( pSat );
332 if ( !RetValue ) printf( "Error: SAT solver became UNSAT at a wrong place.\n" );
333 return 1;
334}
335
347word Acb_ComputeFunction( sat_solver * pSat, int PivotVar, int FreeVar, Vec_Int_t * vDivVars, int fCompl )
348{
349 int fExpand = 0;
350 word uCube, uTruth = 0;
351 Vec_Int_t * vTempLits = Vec_IntAlloc( 100 );
352 int status, i, iVar, iLit, nFinal, * pFinal, pLits[2];
353 assert( FreeVar < sat_solver_nvars(pSat) );
354// if ( fCompl )
355// pLits[0] = Abc_Var2Lit( sat_solver_nvars(pSat)-2, 0 ); // F = 1
356// else
357 pLits[0] = Abc_Var2Lit( PivotVar, fCompl ); // F = 1
358 pLits[1] = Abc_Var2Lit( FreeVar, 0 ); // iNewLit
359 while ( 1 )
360 {
361 // find onset minterm
362 status = sat_solver_solve( pSat, pLits, pLits + 2, 0, 0, 0, 0 );
363 if ( status == l_False )
364 {
365 Vec_IntFree( vTempLits );
366 return uTruth;
367 }
368 assert( status == l_True );
369 if ( fExpand )
370 {
371 // collect divisor literals
372 Vec_IntFill( vTempLits, 1, Abc_LitNot(pLits[0]) ); // F = 0
373 Vec_IntForEachEntry( vDivVars, iVar, i )
374 Vec_IntPush( vTempLits, sat_solver_var_literal(pSat, iVar) );
375 // check against offset
376 status = sat_solver_solve( pSat, Vec_IntArray(vTempLits), Vec_IntLimit(vTempLits), 0, 0, 0, 0 );
377 if ( status != l_False )
378 printf( "Failed internal check during function comptutation.\n" );
379 assert( status == l_False );
380 // compute cube and add clause
381 nFinal = sat_solver_final( pSat, &pFinal );
382 Vec_IntFill( vTempLits, 1, Abc_LitNot(pLits[1]) ); // NOT(iNewLit)
383 for ( i = 0; i < nFinal; i++ )
384 if ( pFinal[i] != pLits[0] )
385 Vec_IntPush( vTempLits, pFinal[i] );
386 }
387 else
388 {
389 // collect divisor literals
390 Vec_IntFill( vTempLits, 1, Abc_LitNot(pLits[1]) );// NOT(iNewLit)
391 Vec_IntForEachEntry( vDivVars, iVar, i )
392 Vec_IntPush( vTempLits, Abc_LitNot(sat_solver_var_literal(pSat, iVar)) );
393 }
394 uCube = ~(word)0;
395 Vec_IntForEachEntryStart( vTempLits, iLit, i, 1 )
396 {
397 iVar = Vec_IntFind( vDivVars, Abc_Lit2Var(iLit) ); assert( iVar >= 0 );
398 uCube &= Abc_LitIsCompl(iLit) ? s_Truths6[iVar] : ~s_Truths6[iVar];
399 }
400 uTruth |= uCube;
401 status = sat_solver_addclause( pSat, Vec_IntArray(vTempLits), Vec_IntLimit(vTempLits) );
402 if ( status == 0 )
403 {
404 Vec_IntFree( vTempLits );
405 return uTruth;
406 }
407 }
408 Vec_IntFree( vTempLits );
409 assert( 0 );
410 return ~(word)0;
411}
412
413
414
415
416
428void Acb_NtkPrintVec( Acb_Ntk_t * p, Vec_Int_t * vVec, char * pName )
429{
430 int i;
431 printf( "%s: ", pName );
432 for ( i = 0; i < vVec->nSize; i++ )
433 printf( "%d ", vVec->pArray[i] );
434 printf( "\n" );
435}
436void Acb_NtkPrintVec2( Acb_Ntk_t * p, Vec_Int_t * vVec, char * pName )
437{
438 int i;
439 printf( "%s: \n", pName );
440 for ( i = 0; i < vVec->nSize; i++ )
441 Acb_NtkPrintNode( p, vVec->pArray[i] );
442 printf( "\n" );
443}
444void Acb_NtkPrintVecWin( Acb_Ntk_t * p, Vec_Int_t * vVec, char * pName )
445{
446 int i;
447 printf( "%s: \n", pName );
448 for ( i = 0; i < vVec->nSize; i++ )
449 Acb_NtkPrintNode( p, Abc_Lit2Var(vVec->pArray[i]) );
450 printf( "\n" );
451}
452
464void Acb_NtkDivisors_rec( Acb_Ntk_t * p, int iObj, int nTfiLevMin, Vec_Int_t * vDivs )
465{
466 int k, iFanin, * pFanins;
467// if ( !Acb_ObjIsCi(p, iObj) && Acb_ObjLevelD(p, iObj) < nTfiLevMin )
468 if ( !Acb_ObjIsCi(p, iObj) && nTfiLevMin < 0 )
469 return;
470 if ( Acb_ObjSetTravIdCur(p, iObj) )
471 return;
472 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
473 Acb_NtkDivisors_rec( p, iFanin, nTfiLevMin-1, vDivs );
474 Vec_IntPush( vDivs, iObj );
475}
476Vec_Int_t * Acb_NtkDivisors( Acb_Ntk_t * p, int Pivot, int nTfiLevMin, int fDelay )
477{
478 int k, iFanin, * pFanins;
479 Vec_Int_t * vDivs = Vec_IntAlloc( 100 );
480 Acb_NtkIncTravId( p );
481// if ( fDelay ) // delay-oriented
482 if ( 0 ) // delay-oriented
483 {
484 // start from critical fanins
485 assert( Acb_ObjLevelD( p, Pivot ) > 1 );
486 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
487 if ( Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) )
488 Acb_NtkDivisors_rec( p, iFanin, nTfiLevMin, vDivs );
489 // add non-critical fanins
490 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
491 if ( !Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) )
492 if ( !Acb_ObjSetTravIdCur(p, iFanin) )
493 Vec_IntPush( vDivs, iFanin );
494 }
495 else
496 {
497 Acb_NtkDivisors_rec( p, Pivot, nTfiLevMin, vDivs );
498 assert( Vec_IntEntryLast(vDivs) == Pivot );
499 Vec_IntPop( vDivs );
500 // add remaining fanins of the node
501 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
502 if ( !Acb_ObjSetTravIdCur(p, iFanin) )
503 Vec_IntPush( vDivs, iFanin );
504/*
505 // start from critical fanins
506 assert( Acb_ObjLevelD( p, Pivot ) > 1 );
507 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
508 if ( Acb_ObjIsAreaCritical( p, iFanin ) )
509 Acb_NtkDivisors_rec( p, iFanin, nTfiLevMin, vDivs );
510 // add non-critical fanins
511 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
512 if ( !Acb_ObjIsAreaCritical( p, iFanin ) )
513 if ( !Acb_ObjSetTravIdCur(p, iFanin) )
514 Vec_IntPush( vDivs, iFanin );
515*/
516 }
517 return vDivs;
518}
519
531void Acb_ObjMarkTfo_rec( Acb_Ntk_t * p, int iObj, int nTfoLevMax, int nFanMax, Vec_Int_t * vMarked )
532{
533 int iFanout, i;
534 if ( Acb_ObjSetTravIdCur(p, iObj) )
535 return;
536 Vec_IntPush( vMarked, iObj );
537 if ( Acb_ObjLevelD(p, iObj) > nTfoLevMax || Acb_ObjFanoutNum(p, iObj) > nFanMax )
538 return;
539 Acb_ObjForEachFanout( p, iObj, iFanout, i )
540 Acb_ObjMarkTfo_rec( p, iFanout, nTfoLevMax, nFanMax, vMarked );
541}
542Vec_Int_t * Acb_ObjMarkTfo( Acb_Ntk_t * p, Vec_Int_t * vDivs, int Pivot, int nTfoLevMax, int nFanMax )
543{
544 Vec_Int_t * vMarked = Vec_IntAlloc( 1000 );
545 int i, iObj;
546 Acb_NtkIncTravId( p );
547 Acb_ObjSetTravIdCur( p, Pivot );
548 Vec_IntPush( vMarked, Pivot );
549 Vec_IntForEachEntry( vDivs, iObj, i )
550 Acb_ObjMarkTfo_rec( p, iObj, nTfoLevMax, nFanMax, vMarked );
551 return vMarked;
552}
553void Acb_ObjMarkTfo2( Acb_Ntk_t * p, Vec_Int_t * vMarked )
554{
555 int i, Node;
556 Acb_NtkIncTravId( p );
557 Vec_IntForEachEntry( vMarked, Node, i )
558 Acb_ObjSetTravIdCur( p, Node );
559}
560
572int Acb_ObjLabelTfo_rec( Acb_Ntk_t * p, int iObj, int nTfoLevMax, int nFanMax, int fFirst )
573{
574 int iFanout, i, Diff, fHasNone = 0;
575 if ( (Diff = Acb_ObjTravIdDiff(p, iObj)) <= 2 )
576 return Diff;
577 Acb_ObjSetTravIdDiff( p, iObj, 2 );
578 if ( Acb_ObjIsCo(p, iObj) || Acb_ObjLevelD(p, iObj) > nTfoLevMax )
579 return 2;
580 if ( Acb_ObjLevelD(p, iObj) == nTfoLevMax || Acb_ObjFanoutNum(p, iObj) > nFanMax )
581 {
582 if ( Diff == 3 ) // belongs to TFO of TFI
583 Acb_ObjSetTravIdDiff( p, iObj, 1 ); // root
584 return Acb_ObjTravIdDiff(p, iObj);
585 }
586 Acb_ObjForEachFanout( p, iObj, iFanout, i )
587 if ( !fFirst || Acb_ObjIsDelayCriticalFanin(p, iFanout, iObj) )
588 fHasNone |= 2 == Acb_ObjLabelTfo_rec( p, iFanout, nTfoLevMax, nFanMax, 0 );
589 if ( fHasNone && Diff == 3 ) // belongs to TFO of TFI
590 Acb_ObjSetTravIdDiff( p, iObj, 1 ); // root
591 else if ( !fHasNone )
592 Acb_ObjSetTravIdDiff( p, iObj, 0 ); // inner
593 return Acb_ObjTravIdDiff(p, iObj);
594}
595int Acb_ObjLabelTfo( Acb_Ntk_t * p, int Root, int nTfoLevMax, int nFanMax, int fDelay )
596{
597 Acb_NtkIncTravId( p ); // none (2) marked (3) unmarked (4)
598 Acb_NtkIncTravId( p ); // root (1)
599 Acb_NtkIncTravId( p ); // inner (0)
600 assert( Acb_ObjTravIdDiff(p, Root) > 2 );
601 return Acb_ObjLabelTfo_rec( p, Root, nTfoLevMax, nFanMax, fDelay );
602}
603
615void Acb_ObjDeriveTfo_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vTfo, Vec_Int_t * vRoots, int fFirst )
616{
617 int iFanout, i, Diff = Acb_ObjTravIdDiff(p, iObj);
618 if ( Acb_ObjSetTravIdCur(p, iObj) )
619 return;
620 if ( Diff == 2 ) // root
621 {
622 Vec_IntPush( vRoots, iObj );
623 Vec_IntPush( vTfo, iObj );
624 return;
625 }
626 assert( Diff == 1 );
627 Acb_ObjForEachFanout( p, iObj, iFanout, i )
628 if ( !fFirst || Acb_ObjIsDelayCriticalFanin(p, iFanout, iObj) )
629 Acb_ObjDeriveTfo_rec( p, iFanout, vTfo, vRoots, 0 );
630 Vec_IntPush( vTfo, iObj );
631}
632void Acb_ObjDeriveTfo( Acb_Ntk_t * p, int Pivot, int nTfoLevMax, int nFanMax, Vec_Int_t ** pvTfo, Vec_Int_t ** pvRoots, int fDelay )
633{
634 int Res = Acb_ObjLabelTfo( p, Pivot, nTfoLevMax, nFanMax, fDelay );
635 Vec_Int_t * vTfo = *pvTfo = Vec_IntAlloc( 10 );
636 Vec_Int_t * vRoots = *pvRoots = Vec_IntAlloc( 10 );
637 if ( Res ) // none or root
638 return;
639 Acb_NtkIncTravId( p ); // root (2) inner (1) visited (0)
640 Acb_ObjDeriveTfo_rec( p, Pivot, vTfo, vRoots, fDelay );
641 assert( Vec_IntEntryLast(vTfo) == Pivot );
642 Vec_IntPop( vTfo );
643 assert( Vec_IntEntryLast(vRoots) != Pivot );
644 Vec_IntReverseOrder( vTfo );
645 Vec_IntReverseOrder( vRoots );
646}
647
648
660Vec_Int_t * Acb_NtkCollectTfoSideInputs( Acb_Ntk_t * p, int Pivot, Vec_Int_t * vTfo )
661{
662 Vec_Int_t * vSide = Vec_IntAlloc( 100 );
663 int i, k, Node, iFanin, * pFanins;
664 Acb_NtkIncTravId( p );
665 Vec_IntPush( vTfo, Pivot );
666 Vec_IntForEachEntry( vTfo, Node, i )
667 Acb_ObjSetTravIdCur( p, Node );
668 Vec_IntForEachEntry( vTfo, Node, i )
669 Acb_ObjForEachFaninFast( p, Node, pFanins, iFanin, k )
670 if ( !Acb_ObjSetTravIdCur(p, iFanin) && iFanin != Pivot )
671 Vec_IntPush( vSide, iFanin );
672 Vec_IntPop( vTfo );
673 return vSide;
674}
675
687void Acb_NtkCollectNewTfi1_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vTfiNew )
688{
689 int i, iFanin, * pFanins;
690 if ( !Acb_ObjIsTravIdPrev(p, iObj) )
691 return;
692 if ( Acb_ObjSetTravIdCur(p, iObj) )
693 return;
694 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, i )
695 Acb_NtkCollectNewTfi1_rec( p, iFanin, vTfiNew );
696 Vec_IntPush( vTfiNew, iObj );
697}
698void Acb_NtkCollectNewTfi2_rec( Acb_Ntk_t * p, int iObj, Vec_Int_t * vTfiNew )
699{
700 int i, iFanin, * pFanins;
701 int fTravIdPrev = Acb_ObjIsTravIdPrev(p, iObj);
702 if ( Acb_ObjSetTravIdCur(p, iObj) )
703 return;
704 if ( fTravIdPrev && !Acb_ObjIsCi(p, iObj) )
705 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, i )
706 Acb_NtkCollectNewTfi2_rec( p, iFanin, vTfiNew );
707 Vec_IntPush( vTfiNew, iObj );
708}
709Vec_Int_t * Acb_NtkCollectNewTfi( Acb_Ntk_t * p, int Pivot, Vec_Int_t * vDivs, Vec_Int_t * vSide, int * pnDivs )
710{
711 Vec_Int_t * vTfiNew = Vec_IntAlloc( 100 );
712 int i, Node;
713 Acb_NtkIncTravId( p );
714 //Acb_NtkPrintVec( p, vDivs, "vDivs" );
715 Vec_IntForEachEntry( vDivs, Node, i )
716 Acb_NtkCollectNewTfi1_rec( p, Node, vTfiNew );
717//Acb_NtkPrintVec( p, vTfiNew, "vTfiNew" );
718 Acb_NtkCollectNewTfi1_rec( p, Pivot, vTfiNew );
719//Acb_NtkPrintVec( p, vTfiNew, "vTfiNew" );
720 assert( Vec_IntEntryLast(vTfiNew) == Pivot );
721 Vec_IntPop( vTfiNew );
722/*
723 Vec_IntForEachEntry( vDivs, Node, i )
724 {
725 Acb_ObjSetTravIdCur( p, Node );
726 Vec_IntPush( vTfiNew, Node );
727 }
728*/
729 *pnDivs = Vec_IntSize(vTfiNew);
730 Vec_IntForEachEntry( vSide, Node, i )
731 Acb_NtkCollectNewTfi2_rec( p, Node, vTfiNew );
732 Vec_IntPush( vTfiNew, Pivot );
733 return vTfiNew;
734}
735
747Vec_Int_t * Acb_NtkCollectWindow( Acb_Ntk_t * p, int Pivot, Vec_Int_t * vTfi, Vec_Int_t * vTfo, Vec_Int_t * vRoots )
748{
749 Vec_Int_t * vWin = Vec_IntAlloc( 100 );
750 int i, k, iObj, iFanin, * pFanins;
751 assert( Vec_IntEntryLast(vTfi) == Pivot );
752 // mark nodes
753 Acb_NtkIncTravId( p );
754 Vec_IntForEachEntry( vTfi, iObj, i )
755 Acb_ObjSetTravIdCur(p, iObj);
756 // add TFI
757 Vec_IntForEachEntry( vTfi, iObj, i )
758 {
759 int fIsTfiInput = 0;
760 Acb_ObjForEachFaninFast( p, iObj, pFanins, iFanin, k )
761 if ( !Acb_ObjIsTravIdCur(p, iFanin) ) // fanin is not in TFI
762 fIsTfiInput = 1; // mark as leaf
763 Vec_IntPush( vWin, Abc_Var2Lit(iObj, Acb_ObjIsCi(p, iObj) || fIsTfiInput) );
764 }
765 // mark roots
766 Acb_NtkIncTravId( p );
767 Vec_IntForEachEntry( vRoots, iObj, i )
768 Acb_ObjSetTravIdCur(p, iObj);
769 // add TFO
770 Vec_IntForEachEntry( vTfo, iObj, i )
771 {
772 assert( !Acb_ObjIsCo(p, iObj) );
773 Vec_IntPush( vWin, Abc_Var2Lit(iObj, Acb_ObjIsTravIdCur(p, iObj)) );
774 }
775 return vWin;
776}
777
789Vec_Int_t * Acb_NtkWindow( Acb_Ntk_t * p, int Pivot, int nTfiLevs, int nTfoLevs, int nFanMax, int fDelay, int * pnDivs )
790{
791 int fVerbose = 0;
792 //int nTfiLevMin = Acb_ObjLevelD(p, Pivot) - nTfiLevs;
793 int nTfoLevMax = Acb_ObjLevelD(p, Pivot) + nTfoLevs;
794 Vec_Int_t * vWin, * vDivs, * vMarked, * vTfo, * vRoots, * vSide, * vTfi;
795 // collect divisors by traversing limited TFI
796 vDivs = Acb_NtkDivisors( p, Pivot, nTfiLevs, fDelay );
797 if ( fVerbose ) Acb_NtkPrintVec( p, vDivs, "vDivs" );
798 // mark limited TFO of the divisors
799 vMarked = Acb_ObjMarkTfo( p, vDivs, Pivot, nTfoLevMax, nFanMax );
800 // collect TFO and roots
801 Acb_ObjDeriveTfo( p, Pivot, nTfoLevMax, nFanMax, &vTfo, &vRoots, 0 );//fDelay );
802 if ( fVerbose ) Acb_NtkPrintVec( p, vTfo, "vTfo" );
803 if ( fVerbose ) Acb_NtkPrintVec( p, vRoots, "vRoots" );
804 // collect side inputs of the TFO
805 vSide = Acb_NtkCollectTfoSideInputs( p, Pivot, vTfo );
806 if ( fVerbose ) Acb_NtkPrintVec( p, vSide, "vSide" );
807 // mark limited TFO of the divisors
808 //Acb_ObjMarkTfo( p, vDivs, Pivot, nTfoLevMax, nFanMax );
809 Acb_ObjMarkTfo2( p, vMarked );
810 Vec_IntFree( vMarked );
811 // collect new TFI
812 vTfi = Acb_NtkCollectNewTfi( p, Pivot, vDivs, vSide, pnDivs );
813 if ( fVerbose ) Acb_NtkPrintVec( p, vTfi, "vTfi" );
814 Vec_IntFree( vSide );
815 Vec_IntFree( vDivs );
816 // collect all nodes
817 vWin = Acb_NtkCollectWindow( p, Pivot, vTfi, vTfo, vRoots );
818 // cleanup
819 Vec_IntFree( vTfi );
820 Vec_IntFree( vTfo );
821 Vec_IntFree( vRoots );
822 return vWin;
823}
824
825
826
838static inline void Vec_IntVars2Vars( Vec_Int_t * p, int Shift )
839{
840 int i;
841 for ( i = 0; i < p->nSize; i++ )
842 p->pArray[i] += Shift;
843}
844static inline void Vec_IntVars2Lits( Vec_Int_t * p, int Shift, int fCompl )
845{
846 int i;
847 for ( i = 0; i < p->nSize; i++ )
848 p->pArray[i] = Abc_Var2Lit( p->pArray[i] + Shift, fCompl );
849}
850static inline void Vec_IntLits2Vars( Vec_Int_t * p, int Shift )
851{
852 int i;
853 for ( i = 0; i < p->nSize; i++ )
854 p->pArray[i] = Abc_Lit2Var( p->pArray[i] ) + Shift;
855}
856static inline void Vec_IntRemap( Vec_Int_t * p, Vec_Int_t * vMap )
857{
858 int i;
859 for ( i = 0; i < p->nSize; i++ )
860 p->pArray[i] = Vec_IntEntry(vMap, p->pArray[i]);
861}
862
863static inline void Acb_WinPrint( Acb_Ntk_t * p, Vec_Int_t * vWin, int Pivot, int nDivs )
864{
865 int i, Node;
866 printf( "Window for node %d with %d divisors:\n", Pivot, nDivs );
867 Vec_IntForEachEntry( vWin, Node, i )
868 {
869 if ( i == nDivs )
870 printf( " | " );
871 if ( Abc_Lit2Var(Node) == Pivot )
872 printf( "(%d) ", Pivot );
873 else
874 printf( "%s%d ", Abc_LitIsCompl(Node) ? "*":"", Abc_Lit2Var(Node) );
875 }
876 printf( "\n" );
877}
878
879static inline void Acb_NtkOrderByRefCount( Acb_Ntk_t * p, Vec_Int_t * vSupp )
880{
881 int i, j, best_i, nSize = Vec_IntSize(vSupp);
882 int * pArray = Vec_IntArray(vSupp);
883 for ( i = 0; i < nSize-1; i++ )
884 {
885 best_i = i;
886 for ( j = i+1; j < nSize; j++ )
887 if ( Acb_ObjFanoutNum(p, pArray[j]) > Acb_ObjFanoutNum(p, pArray[best_i]) )
888 best_i = j;
889 ABC_SWAP( int, pArray[i], pArray[best_i] );
890 }
891}
892
893static inline void Acb_NtkRemapIntoSatVariables( Acb_Ntk_t * p, Vec_Int_t * vSupp )
894{
895 int k, iFanin;
896 Vec_IntForEachEntry( vSupp, iFanin, k )
897 {
898 assert( Acb_ObjFunc(p, iFanin) >= 0 );
899 Vec_IntWriteEntry( vSupp, k, Acb_ObjFunc(p, iFanin) );
900 }
901}
902
914int Acb_NtkFindSupp1( Acb_Ntk_t * p, int Pivot, sat_solver * pSat, int nVars, int nDivs, Vec_Int_t * vWin, Vec_Int_t * vSupp )
915{
916 int nSuppNew, status, k, iFanin, * pFanins;
917 Vec_IntClear( vSupp );
918 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
919 Vec_IntPush( vSupp, iFanin );
920 Acb_NtkOrderByRefCount( p, vSupp );
921 Acb_NtkRemapIntoSatVariables( p, vSupp );
922 Vec_IntVars2Lits( vSupp, 2*nVars, 0 );
923 status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 );
924 if ( status != l_False )
925 printf( "Failed internal check at node %d.\n", Pivot );
926 assert( status == l_False );
927 nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 );
928 Vec_IntShrink( vSupp, nSuppNew );
929 Vec_IntLits2Vars( vSupp, -2*nVars );
930 return Vec_IntSize(vSupp) < Acb_ObjFaninNum(p, Pivot);
931}
932
933static int StrCount = 0;
934
935int Acb_NtkFindSupp2( Acb_Ntk_t * p, int Pivot, sat_solver * pSat, int nVars, int nDivs, Vec_Int_t * vWin, Vec_Int_t * vSupp, int nLutSize, int fDelay )
936{
937 int nSuppNew, status, k, iFanin, * pFanins, k2, iFanin2, * pFanins2;
938 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
939 assert( Acb_ObjFunc(p, iFanin) >= 0 && Acb_ObjFunc(p, iFanin) < nDivs );
940 if ( fDelay )
941 {
942 // add non-timing-critical fanins
943 int nNonCrits, k2, iFanin2 = 0, * pFanins2;
944 assert( Acb_ObjLevelD( p, Pivot ) > 1 );
945 Vec_IntClear( vSupp );
946 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
947 if ( !Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) )
948 Vec_IntPush( vSupp, iFanin );
949 nNonCrits = Vec_IntSize(vSupp);
950 // add fanins of timing critical fanins
951 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
952 if ( Acb_ObjIsDelayCriticalFanin( p, Pivot, iFanin ) )
953 Acb_ObjForEachFaninFast( p, iFanin, pFanins2, iFanin2, k2 )
954 Vec_IntPushUnique( vSupp, iFanin2 );
955 assert( nNonCrits < Vec_IntSize(vSupp) );
956 // sort additional fanins by level
957 Vec_IntSelectSortCost( Vec_IntArray(vSupp) + nNonCrits, Vec_IntSize(vSupp) - nNonCrits, &p->vLevelD );
958 // translate to SAT vars
959 Vec_IntForEachEntry( vSupp, iFanin, k )
960 {
961 assert( Acb_ObjFunc(p, iFanin) >= 0 );
962 Vec_IntWriteEntry( vSupp, k, Acb_ObjFunc(p, iFanin) );
963 }
964 // solve for these fanins
965 Vec_IntVars2Lits( vSupp, 2*nVars, 0 );
966 status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 );
967 if ( status != l_False )
968 printf( "Failed internal check at node %d.\n", Pivot );
969 assert( status == l_False );
970 nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 );
971 Vec_IntShrink( vSupp, nSuppNew );
972 Vec_IntLits2Vars( vSupp, -2*nVars );
973 return Vec_IntSize(vSupp) <= nLutSize;
974 }
975 // iterate through different fanout free cones
976 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
977 {
978 if ( !Acb_ObjIsAreaCritical(p, iFanin) )
979 continue;
980 // collect fanins of the root node
981 Vec_IntClear( vSupp );
982 Acb_ObjForEachFaninFast( p, Pivot, pFanins2, iFanin2, k2 )
983 if ( iFanin != iFanin2 )
984 Vec_IntPush( vSupp, iFanin2 );
985 // collect fanins of the selected node
986 Acb_ObjForEachFaninFast( p, iFanin, pFanins2, iFanin2, k2 )
987 Vec_IntPushUnique( vSupp, iFanin2 );
988 // sort fanins by level
989 Vec_IntSelectSortCost( Vec_IntArray(vSupp), Vec_IntSize(vSupp), &p->vLevelD );
990 //Acb_NtkOrderByRefCount( p, vSupp );
991 Acb_NtkRemapIntoSatVariables( p, vSupp );
992 // solve for these fanins
993 Vec_IntVars2Lits( vSupp, 2*nVars, 0 );
994 status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 );
995 if ( status != l_False )
996 printf( "Failed internal check at node %d.\n", Pivot );
997 assert( status == l_False );
998 nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 );
999 Vec_IntShrink( vSupp, nSuppNew );
1000 Vec_IntLits2Vars( vSupp, -2*nVars );
1001 if ( Vec_IntSize(vSupp) <= nLutSize )
1002 return 1;
1003 }
1004 return 0;
1005}
1006
1007int Acb_NtkFindSupp3( Acb_Ntk_t * p, int Pivot, sat_solver * pSat, int nVars, int nDivs, Vec_Int_t * vWin, Vec_Int_t * vSupp, int nLutSize, int fDelay )
1008{
1009 int nSuppNew, status, k, iFanin, * pFanins, k2, iFanin2, * pFanins2, k3, iFanin3, * pFanins3, NodeMark;
1010
1011 if ( fDelay )
1012 return 0;
1013
1014 // iterate through pairs of fanins with one fanouts
1015 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
1016 {
1017 if ( !Acb_ObjIsAreaCritical(p, iFanin) )
1018 continue;
1019 Acb_ObjForEachFaninFast( p, Pivot, pFanins2, iFanin2, k2 )
1020 {
1021 if ( !Acb_ObjIsAreaCritical(p, iFanin2) || k2 == k )
1022 continue;
1023 // iFanin and iFanin2 have 1 fanout
1024 assert( iFanin != iFanin2 );
1025
1026 // collect fanins of the root node
1027 Vec_IntClear( vSupp );
1028 Acb_ObjForEachFaninFast( p, Pivot, pFanins3, iFanin3, k3 )
1029 if ( iFanin3 != iFanin && iFanin3 != iFanin2 )
1030 {
1031 assert( Acb_ObjFunc(p, iFanin3) >= 0 );
1032 Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars, 0) );
1033 }
1034 NodeMark = Vec_IntSize(vSupp);
1035
1036 // collect fanins of the second node
1037 Acb_ObjForEachFaninFast( p, iFanin, pFanins3, iFanin3, k3 )
1038 {
1039 assert( Acb_ObjFunc(p, iFanin3) >= 0 );
1040 Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) );
1041 }
1042 // collect fanins of the third node
1043 Acb_ObjForEachFaninFast( p, iFanin2, pFanins3, iFanin3, k3 )
1044 {
1045 assert( Acb_ObjFunc(p, iFanin3) >= 0 );
1046 Vec_IntPushUnique( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) );
1047 }
1048 assert( Vec_IntCheckUniqueSmall(vSupp) );
1049
1050 // sort fanins by level
1051 //Vec_IntSelectSortCost( Vec_IntArray(vSupp) + NodeMark, Vec_IntSize(vSupp) - NodeMark, &p->vLevelD );
1052 // solve for these fanins
1053 status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 );
1054 if ( status != l_False )
1055 continue;
1056 assert( status == l_False );
1057 nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 );
1058 Vec_IntShrink( vSupp, nSuppNew );
1059 Vec_IntLits2Vars( vSupp, -6*nVars );
1060 Vec_IntSort( vSupp, 1 );
1061 // count how many belong to H; the rest belong to G
1062 NodeMark = 0;
1063 Vec_IntForEachEntry( vSupp, iFanin3, k3 )
1064 if ( iFanin3 >= nDivs )
1065 Vec_IntWriteEntry( vSupp, k3, iFanin3 - nDivs );
1066 else
1067 NodeMark++;
1068 if ( NodeMark == 0 )
1069 {
1070 //printf( "Obj %d: Special case 1 (vars = %d)\n", Pivot, Vec_IntSize(vSupp) );
1071 continue;
1072 }
1073 assert( NodeMark > 0 );
1074 if ( Vec_IntSize(vSupp) - NodeMark <= nLutSize )
1075 return NodeMark;
1076 }
1077 }
1078
1079 // iterate through fanins with one fanout and their fanins with one fanout
1080 Acb_ObjForEachFaninFast( p, Pivot, pFanins, iFanin, k )
1081 {
1082 if ( !Acb_ObjIsAreaCritical(p, iFanin) )
1083 continue;
1084 Acb_ObjForEachFaninFast( p, iFanin, pFanins2, iFanin2, k2 )
1085 {
1086 if ( !Acb_ObjIsAreaCritical(p, iFanin2) )
1087 continue;
1088 // iFanin and iFanin2 have 1 fanout
1089 assert( iFanin != iFanin2 );
1090
1091 // collect fanins of the root node
1092 Vec_IntClear( vSupp );
1093 Acb_ObjForEachFaninFast( p, Pivot, pFanins3, iFanin3, k3 )
1094 if ( iFanin3 != iFanin && iFanin3 != iFanin2 )
1095 Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars, 0) );
1096 NodeMark = Vec_IntSize(vSupp);
1097
1098 // collect fanins of the second node
1099 Acb_ObjForEachFaninFast( p, iFanin, pFanins3, iFanin3, k3 )
1100 if ( iFanin3 != iFanin2 )
1101 Vec_IntPush( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) );
1102 // collect fanins of the third node
1103 Acb_ObjForEachFaninFast( p, iFanin2, pFanins3, iFanin3, k3 )
1104 {
1105 assert( Acb_ObjFunc(p, iFanin3) >= 0 );
1106 Vec_IntPushUnique( vSupp, Abc_Var2Lit(Acb_ObjFunc(p, iFanin3) + 6*nVars + nDivs, 0) );
1107 }
1108 assert( Vec_IntCheckUniqueSmall(vSupp) );
1109
1110 // sort fanins by level
1111 //Vec_IntSelectSortCost( Vec_IntArray(vSupp) + NodeMark, Vec_IntSize(vSupp) - NodeMark, &p->vLevelD );
1112 //Sat_SolverWriteDimacs( pSat, NULL, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0 );
1113 // solve for these fanins
1114 status = sat_solver_solve( pSat, Vec_IntArray(vSupp), Vec_IntLimit(vSupp), 0, 0, 0, 0 );
1115 if ( status != l_False )
1116 printf( "Failed internal check at node %d.\n", Pivot );
1117 assert( status == l_False );
1118 nSuppNew = sat_solver_minimize_assumptions( pSat, Vec_IntArray(vSupp), Vec_IntSize(vSupp), 0 );
1119 Vec_IntShrink( vSupp, nSuppNew );
1120 Vec_IntLits2Vars( vSupp, -6*nVars );
1121 Vec_IntSort( vSupp, 1 );
1122 // count how many belong to H; the rest belong to G
1123 NodeMark = 0;
1124 Vec_IntForEachEntry( vSupp, iFanin3, k3 )
1125 if ( iFanin3 >= nDivs )
1126 Vec_IntWriteEntry( vSupp, k3, iFanin3 - nDivs );
1127 else
1128 NodeMark++;
1129 if ( NodeMark == 0 )
1130 {
1131 //printf( "Obj %d: Special case 2 (vars = %d)\n", Pivot, Vec_IntSize(vSupp) );
1132 continue;
1133 }
1134 assert( NodeMark > 0 );
1135 if ( Vec_IntSize(vSupp) - NodeMark <= nLutSize )
1136 return NodeMark;
1137 }
1138 }
1139
1140 return 0;
1141}
1142
1154typedef struct Acb_Mfs_t_ Acb_Mfs_t;
1155struct Acb_Mfs_t_
1156{
1157 Acb_Ntk_t * pNtk; // network
1158 Acb_Par_t * pPars; // parameters
1159 sat_solver * pSat[3]; // SAT solvers
1160 Vec_Int_t * vSupp; // support
1161 Vec_Int_t * vFlip; // support
1162 Vec_Int_t * vValues; // support
1163 int nNodes; // nodes
1164 int nWins; // windows
1165 int nWinsAll; // windows
1166 int nDivsAll; // windows
1167 int nChanges[8]; // changes
1168 int nOvers; // overflows
1169 int nTwoNodes; // two nodes
1170 abctime timeTotal;
1171 abctime timeCnf;
1172 abctime timeSol;
1173 abctime timeWin;
1174 abctime timeSat;
1175 abctime timeSatU;
1176 abctime timeSatS;
1177};
1178Acb_Mfs_t * Acb_MfsStart( Acb_Ntk_t * pNtk, Acb_Par_t * pPars )
1179{
1180 Acb_Mfs_t * p = ABC_CALLOC( Acb_Mfs_t, 1 );
1181 p->pNtk = pNtk;
1182 p->pPars = pPars;
1183 p->timeTotal = Abc_Clock();
1184 p->pSat[0] = sat_solver_new();
1185 p->pSat[1] = sat_solver_new();
1186 p->pSat[2] = sat_solver_new();
1187 p->vSupp = Vec_IntAlloc(100);
1188 p->vFlip = Vec_IntAlloc(100);
1189 p->vValues = Vec_IntAlloc(100);
1190 return p;
1191}
1192void Acb_MfsStop( Acb_Mfs_t * p )
1193{
1194 Vec_IntFree( p->vFlip );
1195 Vec_IntFree( p->vSupp );
1196 Vec_IntFree( p->vValues );
1197 sat_solver_delete( p->pSat[0] );
1198 sat_solver_delete( p->pSat[1] );
1199 sat_solver_delete( p->pSat[2] );
1200 ABC_FREE( p );
1201}
1202static inline int Acb_NtkObjMffcEstimate( Acb_Ntk_t * pNtk, int iObj )
1203{
1204 int k, iFanin, * pFanins, Count = 0, iFaninCrit = -1;
1205 Acb_ObjForEachFaninFast( pNtk, iObj, pFanins, iFanin, k )
1206 if ( Acb_ObjIsAreaCritical(pNtk, iFanin) )
1207 iFaninCrit = iFanin, Count++;
1208 if ( Count != 1 )
1209 return Count;
1210 Acb_ObjForEachFaninFast( pNtk, iFaninCrit, pFanins, iFanin, k )
1211 if ( Acb_ObjIsAreaCritical(pNtk, iFanin) )
1212 Count++;
1213 return Count;
1214}
1215
1227void Acb_NtkOptNodeAnalyze( Acb_Mfs_t * p, int PivotVar, int nDivs, int nValues, int * pValues, Vec_Int_t * vSupp )
1228{
1229 word OnSet[64] = {0};
1230 word OffSet[64] = {0};
1231 word Diffs[64] = {0};
1232 int s, nScope = 1 + 2*nDivs, d, i;
1233 int f, nFrames = nValues / nScope;
1234 int start = nDivs < 64 ? 0 : nDivs - 64;
1235 int stop = nDivs < 64 ? nDivs : 64;
1236 assert( nValues % nScope == 0 );
1237 assert( nFrames <= 16 );
1238 for ( f = 0; f < nFrames; f++ )
1239 {
1240 int * pStart = pValues + f * nScope;
1241 int * pOnSet = pStart + 1 + (pStart[0] ? 0 : nDivs);
1242 int * pOffSet = pStart + 1 + (pStart[0] ? nDivs : 0);
1243
1244 printf( "%2d:", f );
1245 for ( s = start; s < stop; s++ )
1246 printf( "%d", pOnSet[s] );
1247 printf( "\n" );
1248
1249 printf( "%2d:", f );
1250 for ( s = start; s < stop; s++ )
1251 printf( "%d", pOffSet[s] );
1252 printf( "\n" );
1253
1254 for ( s = start; s < stop; s++ )
1255 {
1256 if ( pOnSet[s] ) OnSet[f] |= (((word)1) << (s-start));
1257 if ( pOffSet[s] ) OffSet[f] |= (((word)1) << (s-start));
1258 }
1259 }
1260 d = 0;
1261 for ( f = 0; f < nFrames; f++ )
1262 for ( s = 0; s < nFrames; s++ )
1263 {
1264 for ( i = 0; i < d; i++ )
1265 if ( Diffs[i] == (OnSet[f] ^ OffSet[s]) )
1266 break;
1267 if ( i < d )
1268 continue;
1269 if ( d < 64 )
1270 Diffs[d++] = OnSet[f] ^ OffSet[s];
1271 }
1272
1273 printf( "Divisors = %d. Frames = %d. Patterns = %d.\n", nDivs, nFrames, d );
1274 printf( " " );
1275 for ( s = start; s < stop; s++ )
1276 printf( "%d", s / 10 );
1277 printf( "\n" );
1278 printf( " " );
1279 for ( s = start; s < stop; s++ )
1280 printf( "%d", s % 10 );
1281 printf( "\n" );
1282 printf( " " );
1283 for ( s = start; s < stop; s++ )
1284 printf( "%c", Vec_IntFind(vSupp, s) >= 0 ? 'a' + Vec_IntFind(vSupp, s) : ' ' );
1285 printf( "\n" );
1286 for ( s = 0; s < d; s++ )
1287 {
1288 printf( "%2d:", s );
1289 for ( f = 0; f < stop; f++ )
1290 printf( "%c", ((Diffs[s] >> f) & 1) ? '*' : ' ' );
1291 printf( "\n" );
1292 }
1293}
1294
1295int Acb_NtkOptNode( Acb_Mfs_t * p, int Pivot )
1296{
1297 Cnf_Dat_t * pCnf = NULL; abctime clk;
1298 Vec_Int_t * vWin = NULL; word uTruth;
1299 int Result, PivotVar, nDivs = 0, RetValue = 0, c;
1300 assert( Acb_ObjFanoutNum(p->pNtk, Pivot) > 0 );
1301 p->nWins++;
1302
1303 // compute divisors and window for this target node with these taboo nodes
1304 clk = Abc_Clock();
1305 vWin = Acb_NtkWindow( p->pNtk, Pivot, p->pPars->nTfiLevMax, p->pPars->nTfoLevMax, p->pPars->nFanoutMax, !p->pPars->fArea, &nDivs );
1306 p->nWinsAll += Vec_IntSize(vWin);
1307 p->nDivsAll += nDivs;
1308 p->timeWin += Abc_Clock() - clk;
1309 PivotVar = Vec_IntFind( vWin, Abc_Var2Lit(Pivot, 0) );
1310 if ( p->pPars->fVerbose )
1311 printf( "Node %d: Window contains %d objects and %d divisors. ", Pivot, Vec_IntSize(vWin), nDivs );
1312// Acb_WinPrint( p->pNtk, vWin, Pivot, nDivs );
1313// Acb_NtkPrintVecWin( p->pNtk, vWin, "Win" );
1314 if ( Vec_IntSize(vWin) > p->pPars->nWinNodeMax )
1315 {
1316 p->nOvers++;
1317 if ( p->pPars->fVerbose )
1318 printf( "Too many divisors.\n" );
1319 goto cleanup;
1320 }
1321
1322 // derive CNF
1323 clk = Abc_Clock();
1324 pCnf = Acb_NtkWindow2Cnf( p->pNtk, vWin, Pivot );
1325 assert( PivotVar == Acb_ObjFunc(p->pNtk, Pivot) );
1326 Cnf_DataCollectFlipLits( pCnf, PivotVar, p->vFlip );
1327 p->timeCnf += Abc_Clock() - clk;
1328
1329 // derive SAT solver
1330 clk = Abc_Clock();
1331 Acb_NtkWindow2Solver( p->pSat[0], pCnf, p->vFlip, PivotVar, nDivs, 1 );
1332 p->timeSol += Abc_Clock() - clk;
1333 // check constants
1334 for ( c = 0; c < 2; c++ )
1335 {
1336 int Lit = Abc_Var2Lit( PivotVar, c );
1337 int status = sat_solver_solve( p->pSat[0], &Lit, &Lit + 1, 0, 0, 0, 0 );
1338 if ( status == l_False )
1339 {
1340 p->nChanges[0]++;
1341 if ( p->pPars->fVerbose )
1342 printf( "Found constant %d.\n", c );
1343 Acb_NtkUpdateNode( p->pNtk, Pivot, c ? ~(word)0 : 0, NULL );
1344 RetValue = 1;
1345 goto cleanup;
1346 }
1347 assert( status == l_True );
1348 }
1349
1350 // derive SAT solver
1351 clk = Abc_Clock();
1352 Acb_NtkWindow2Solver( p->pSat[1], pCnf, p->vFlip, PivotVar, nDivs, 2 );
1353 p->timeSol += Abc_Clock() - clk;
1354
1355 // try to remove useless fanins
1356 if ( p->pPars->fArea )
1357 {
1358 int fEnableProfile = 0;
1359 if ( fEnableProfile )
1360 {
1361 // alloc
1362 if ( p->pSat[1]->user_values.cap == 0 )
1363 veci_new(&p->pSat[1]->user_values);
1364 else
1365 p->pSat[1]->user_values.size = 0;
1366 if ( p->pSat[1]->user_vars.cap == 0 )
1367 veci_new(&p->pSat[1]->user_vars);
1368 else
1369 p->pSat[1]->user_vars.size = 0;
1370 // set variables
1371 veci_push(&p->pSat[1]->user_vars, PivotVar);
1372 for ( c = 0; c < nDivs; c++ )
1373 veci_push(&p->pSat[1]->user_vars, c);
1374 for ( c = 0; c < nDivs; c++ )
1375 veci_push(&p->pSat[1]->user_vars, c+pCnf->nVars);
1376 }
1377
1378 // perform solving
1379 clk = Abc_Clock();
1380 Result = Acb_NtkFindSupp1( p->pNtk, Pivot, p->pSat[1], pCnf->nVars, nDivs, vWin, p->vSupp );
1381 p->timeSat += Abc_Clock() - clk;
1382 // undo variables
1383 p->pSat[1]->user_vars.size = 0;
1384 if ( Result )
1385 {
1386 if ( Vec_IntSize(p->vSupp) == 0 )
1387 p->nChanges[0]++;
1388 else
1389 p->nChanges[1]++;
1390 assert( Vec_IntSize(p->vSupp) < p->pPars->nLutSize );
1391 if ( p->pPars->fVerbose )
1392 printf( "Found %d inputs: ", Vec_IntSize(p->vSupp) );
1393 uTruth = Acb_ComputeFunction( p->pSat[0], PivotVar, sat_solver_nvars(p->pSat[0])-1, p->vSupp, 0 );
1394 if ( p->pPars->fVerbose )
1395 Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) );
1396 if ( p->pPars->fVerbose )
1397 printf( "\n" );
1398 // create support in terms of nodes
1399 Vec_IntRemap( p->vSupp, vWin );
1400 Vec_IntLits2Vars( p->vSupp, 0 );
1401 Acb_NtkUpdateNode( p->pNtk, Pivot, uTruth, p->vSupp );
1402 RetValue = 1;
1403 goto cleanup;
1404 }
1405 if ( fEnableProfile )
1406 {
1407 // analyze the resulting values
1408 Acb_NtkOptNodeAnalyze( p, PivotVar, nDivs, p->pSat[1]->user_values.size, p->pSat[1]->user_values.ptr, p->vSupp );
1409 p->pSat[1]->user_values.size = 0;
1410 }
1411 }
1412
1413 if ( Acb_NtkObjMffcEstimate(p->pNtk, Pivot) >= 1 )
1414 {
1415 // check for one-node implementation
1416 clk = Abc_Clock();
1417 Result = Acb_NtkFindSupp2( p->pNtk, Pivot, p->pSat[1], pCnf->nVars, nDivs, vWin, p->vSupp, p->pPars->nLutSize, !p->pPars->fArea );
1418 p->timeSat += Abc_Clock() - clk;
1419 if ( Result )
1420 {
1421 p->nChanges[2]++;
1422 assert( Vec_IntSize(p->vSupp) <= p->pPars->nLutSize );
1423 if ( p->pPars->fVerbose )
1424 printf( "Found %d inputs: ", Vec_IntSize(p->vSupp) );
1425 uTruth = Acb_ComputeFunction( p->pSat[0], PivotVar, sat_solver_nvars(p->pSat[0])-1, p->vSupp, 0 );
1426 if ( p->pPars->fVerbose )
1427 Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) );
1428 if ( p->pPars->fVerbose )
1429 printf( "\n" );
1430 // create support in terms of nodes
1431 Vec_IntRemap( p->vSupp, vWin );
1432 Vec_IntLits2Vars( p->vSupp, 0 );
1433 Acb_NtkUpdateNode( p->pNtk, Pivot, uTruth, p->vSupp );
1434 RetValue = 1;
1435 goto cleanup;
1436 }
1437 }
1438
1439//#if 0
1440 if ( p->pPars->fUseAshen && Acb_NtkObjMffcEstimate(p->pNtk, Pivot) >= 2 )// && Pivot != 70 )
1441 {
1442 p->nTwoNodes++;
1443 // derive SAT solver
1444 clk = Abc_Clock();
1445 Acb_NtkWindow2Solver( p->pSat[2], pCnf, p->vFlip, PivotVar, nDivs, 6 );
1446 p->timeSol += Abc_Clock() - clk;
1447
1448 // check for two-node implementation
1449 clk = Abc_Clock();
1450 Result = Acb_NtkFindSupp3( p->pNtk, Pivot, p->pSat[2], pCnf->nVars, nDivs, vWin, p->vSupp, p->pPars->nLutSize, !p->pPars->fArea );
1451 p->timeSat += Abc_Clock() - clk;
1452 if ( Result )
1453 {
1454 int fVerbose = 1;
1455 int i, k, Lit, Var, Var2, status, NodeNew, fBecameUnsat = 0, fCompl = 0;
1456 assert( Result < p->pPars->nLutSize );
1457 assert( Vec_IntSize(p->vSupp)-Result <= p->pPars->nLutSize );
1458 if ( fVerbose || p->pPars->fVerbose )
1459 printf( "Obj %5d: Found %d Hvars and %d Gvars: ", Pivot, Result, Vec_IntSize(p->vSupp)-Result );
1460 // p->vSupp contains G variables (Vec_IntSize(p->vSupp)-Result) followed by H variables (Result)
1461 //sat_solver_restart( p->pSat[1] );
1462 //Acb_NtkWindow2Solver( p->pSat[1], pCnf, p->vFlip, PivotVar, nDivs, 2 );
1463
1464 // constrain H-variables to be equal
1465 Vec_IntForEachEntryStart( p->vSupp, Var, i, Vec_IntSize(p->vSupp)-Result ) // H variables
1466 {
1467 assert( Var >= 0 && Var < nDivs );
1468 assert( Var + 2*pCnf->nVars < sat_solver_nvars(p->pSat[1]) );
1469 Lit = Abc_Var2Lit( Var + 2*pCnf->nVars, 0 ); // HVars are the same
1470 if ( !sat_solver_addclause( p->pSat[1], &Lit, &Lit + 1 ) )
1471 { if ( fVerbose || p->pPars->fVerbose ) printf( "Error: SAT solver became UNSAT at a wrong place (place 2). " ); fBecameUnsat = 1; }
1472 }
1473 // find one satisfying assighment
1474 status = sat_solver_solve( p->pSat[1], NULL, NULL, 0, 0, 0, 0 );
1475 assert( status == l_True );
1476 // get assignment of the function
1477 fCompl = !sat_solver_var_value( p->pSat[1], PivotVar );
1478 // constrain second set of G-vars to have values equal to the assignment
1479 Vec_IntForEachEntryStop( p->vSupp, Var, i, Vec_IntSize(p->vSupp)-Result ) // G variables
1480 {
1481 // check if this is a C-var
1482 Vec_IntForEachEntryStart( p->vSupp, Var2, k, Vec_IntSize(p->vSupp)-Result ) // G variables
1483 if ( Var == Var2 )
1484 break;
1485 if ( k < Vec_IntSize(p->vSupp) ) // do not constrain a C-var
1486 {
1487 if ( fVerbose || p->pPars->fVerbose )
1488 printf( "Found C-var in object %d. ", Pivot );
1489 continue;
1490 }
1491 assert( Var >= 0 && Var < nDivs );
1492 Lit = sat_solver_var_literal( p->pSat[1], Var + pCnf->nVars );
1493 if ( !sat_solver_addclause( p->pSat[1], &Lit, &Lit + 1 ) )
1494 { if ( fVerbose || p->pPars->fVerbose ) printf( "Error: SAT solver became UNSAT at a wrong place (place 1). " ); fBecameUnsat = 1; }
1495 }
1496 if ( fBecameUnsat )
1497 {
1498 StrCount++;
1499 if ( fVerbose || p->pPars->fVerbose )
1500 printf( " Quitting.\n" );
1501 goto cleanup;
1502 }
1503 // consider only G variables
1504 p->vSupp->nSize -= Result;
1505 // truth table
1506 uTruth = Acb_ComputeFunction( p->pSat[1], PivotVar, sat_solver_nvars(p->pSat[1])-1, p->vSupp, fCompl );
1507 if ( fVerbose || p->pPars->fVerbose )
1508 Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) );
1509 if ( uTruth == 0 || ~uTruth == 0 )
1510 {
1511 if ( fVerbose || p->pPars->fVerbose )
1512 printf( " Quitting.\n" );
1513 goto cleanup;
1514 }
1515 p->nChanges[3]++;
1516 // create new node
1517 Vec_IntRemap( p->vSupp, vWin );
1518 Vec_IntLits2Vars( p->vSupp, 0 );
1519 NodeNew = Acb_NtkCreateNode( p->pNtk, uTruth, p->vSupp );
1520 Acb_DeriveCnfForWindowOne( p->pNtk, NodeNew );
1521 Acb_DeriveCnfForNode( p->pNtk, NodeNew, p->pSat[0], sat_solver_nvars(p->pSat[0])-2 );
1522 p->vSupp->nSize += Result;
1523 // collect new variables
1524 Vec_IntForEachEntryStart( p->vSupp, Var, i, Vec_IntSize(p->vSupp)-Result )
1525 Vec_IntWriteEntry( p->vSupp, i-(Vec_IntSize(p->vSupp)-Result), Var );
1526 Vec_IntShrink( p->vSupp, Result );
1527 Vec_IntPush( p->vSupp, sat_solver_nvars(p->pSat[0])-2 );
1528 // truth table
1529 uTruth = Acb_ComputeFunction( p->pSat[0], PivotVar, sat_solver_nvars(p->pSat[0])-1, p->vSupp, 0 );
1530 // create new fanins of the node
1531 if ( fVerbose || p->pPars->fVerbose )
1532 printf( " " );
1533 if ( fVerbose || p->pPars->fVerbose )
1534 Extra_PrintHex( stdout, (unsigned *)&uTruth, Vec_IntSize(p->vSupp) );
1535 if ( fVerbose || p->pPars->fVerbose )
1536 printf( "\n" );
1537 // create support in terms of nodes
1538 Vec_IntPop( p->vSupp );
1539 Vec_IntRemap( p->vSupp, vWin );
1540 Vec_IntLits2Vars( p->vSupp, 0 );
1541 Vec_IntPush( p->vSupp, NodeNew );
1542 Acb_NtkUpdateNode( p->pNtk, Pivot, uTruth, p->vSupp );
1543 RetValue = 2;
1544 goto cleanup;
1545 }
1546 }
1547//#endif
1548
1549 if ( p->pPars->fVerbose )
1550 printf( "\n" );
1551
1552cleanup:
1553 sat_solver_restart( p->pSat[0] );
1554 sat_solver_restart( p->pSat[1] );
1555 sat_solver_restart( p->pSat[2] );
1556 if ( pCnf )
1557 {
1558 Cnf_DataFree( pCnf );
1559 Acb_NtkWindowUndo( p->pNtk, vWin );
1560 }
1561 Vec_IntFreeP( &vWin );
1562 return RetValue;
1563}
1564
1576void Acb_NtkOpt( Acb_Ntk_t * pNtk, Acb_Par_t * pPars )
1577{
1578 Acb_Mfs_t * pMan = Acb_MfsStart( pNtk, pPars );
1579 if ( pPars->fVerbose )
1580 printf( "%s-optimization parameters: TfiLev(I) = %d TfoLev(O) = %d WinMax(W) = %d LutSize = %d\n",
1581 pMan->pPars->fArea ? "Area" : "Delay", pMan->pPars->nTfiLevMax, pMan->pPars->nTfoLevMax, pMan->pPars->nWinNodeMax, pMan->pPars->nLutSize );
1582 Acb_NtkCreateFanout( pNtk ); // fanout data structure
1583 Acb_NtkCleanObjFuncs( pNtk ); // SAT variables
1584 Acb_NtkCleanObjCnfs( pNtk ); // CNF representations
1585 if ( pMan->pPars->fArea )
1586 {
1587 int n = 0, iObj, RetValue, nNodes = Acb_NtkObjNumMax(pNtk);
1588 Vec_Bit_t * vVisited = Vec_BitStart( Acb_NtkObjNumMax(pNtk) );
1589 Acb_NtkUpdateLevelD( pNtk, -1 ); // compute forward logic level
1590 for ( n = 2; n >= 0; n-- )
1591 Acb_NtkForEachNode( pNtk, iObj )
1592 if ( iObj < nNodes && !Vec_BitEntry(vVisited, iObj) && Acb_NtkObjMffcEstimate(pNtk, iObj) >= n )
1593 {
1594 pMan->nNodes++;
1595 //if ( iObj != 103 )
1596 // continue;
1597 //Acb_NtkOptNode( pMan, iObj );
1598 while ( (RetValue = Acb_NtkOptNode(pMan, iObj)) && Acb_ObjFaninNum(pNtk, iObj) );
1599 Vec_BitWriteEntry( vVisited, iObj, 1 );
1600 }
1601 Vec_BitFree( vVisited );
1602 }
1603 else
1604 {
1605 int Value;
1606 Acb_NtkUpdateTiming( pNtk, -1 ); // compute delay information
1607 while ( (Value = (int)Vec_QueTopPriority(pNtk->vQue)) > 0 )
1608 {
1609 int iObj = Vec_QuePop(pNtk->vQue);
1610 if ( !Acb_ObjType(pNtk, iObj) )
1611 continue;
1612 //if ( iObj != 103 )
1613 // continue;
1614 //printf( "Trying node %4d (%4d) ", iObj, Value );
1615 Acb_NtkOptNode( pMan, iObj );
1616 }
1617 }
1618 if ( pPars->fVerbose )
1619 {
1620 pMan->timeTotal = Abc_Clock() - pMan->timeTotal;
1621 printf( "Node = %d Win = %d (Ave = %d) DivAve = %d Change = %d C = %d N1 = %d N2 = %d N3 = %d Over = %d Str = %d 2Node = %d.\n",
1622 pMan->nNodes, pMan->nWins, pMan->nWinsAll/Abc_MaxInt(1, pMan->nWins), pMan->nDivsAll/Abc_MaxInt(1, pMan->nWins),
1623 pMan->nChanges[0] + pMan->nChanges[1] + pMan->nChanges[2] + pMan->nChanges[3],
1624 pMan->nChanges[0], pMan->nChanges[1], pMan->nChanges[2], pMan->nChanges[3], pMan->nOvers, StrCount, pMan->nTwoNodes );
1625 ABC_PRTP( "Windowing ", pMan->timeWin, pMan->timeTotal );
1626 ABC_PRTP( "CNF compute", pMan->timeCnf, pMan->timeTotal );
1627 ABC_PRTP( "Make solver", pMan->timeSol, pMan->timeTotal );
1628 ABC_PRTP( "SAT solving", pMan->timeSat, pMan->timeTotal );
1629// ABC_PRTP( " unsat ", pMan->timeSatU, pMan->timeTotal );
1630// ABC_PRTP( " sat ", pMan->timeSatS, pMan->timeTotal );
1631 ABC_PRTP( "TOTAL ", pMan->timeTotal, pMan->timeTotal );
1632 fflush( stdout );
1633 }
1634 Acb_MfsStop( pMan );
1635 StrCount = 0;
1636}
1637
1641
1642
1643ABC_NAMESPACE_IMPL_END
1644
ABC_SWAP
#define ABC_SWAP(Type, a, b)
Definition abc_global.h:253
abctime
ABC_INT64_T abctime
Definition abc_global.h:332
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition abc_global.h:264
ABC_PRTP
#define ABC_PRTP(a, t, T)
Definition abc_global.h:258
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition abc_global.h:265
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition abc_namespaces.h:54
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition abc_namespaces.h:55
Acb_DeriveCnfForWindowOne
void Acb_DeriveCnfForWindowOne(Acb_Ntk_t *p, int iObj)
Definition acbMfs.c:93
Acb_MfsStop
void Acb_MfsStop(Acb_Mfs_t *p)
Definition acbMfs.c:1192
Acb_DeriveCnfForWindow
Vec_Wec_t * Acb_DeriveCnfForWindow(Acb_Ntk_t *p, Vec_Int_t *vWin, int PivotVar)
Definition acbMfs.c:104
Acb_NtkOptNodeAnalyze
void Acb_NtkOptNodeAnalyze(Acb_Mfs_t *p, int PivotVar, int nDivs, int nValues, int *pValues, Vec_Int_t *vSupp)
Definition acbMfs.c:1227
Acb_NtkFindSupp2
int Acb_NtkFindSupp2(Acb_Ntk_t *p, int Pivot, sat_solver *pSat, int nVars, int nDivs, Vec_Int_t *vWin, Vec_Int_t *vSupp, int nLutSize, int fDelay)
Definition acbMfs.c:935
Acb_NtkWindow2Cnf
Cnf_Dat_t * Acb_NtkWindow2Cnf(Acb_Ntk_t *p, Vec_Int_t *vWinObjs, int Pivot)
Definition acbMfs.c:190
Acb_ObjMarkTfo2
void Acb_ObjMarkTfo2(Acb_Ntk_t *p, Vec_Int_t *vMarked)
Definition acbMfs.c:553
Acb_NtkDivisors_rec
void Acb_NtkDivisors_rec(Acb_Ntk_t *p, int iObj, int nTfiLevMin, Vec_Int_t *vDivs)
Definition acbMfs.c:464
Acb_TranslateCnf
void Acb_TranslateCnf(Vec_Int_t *vClas, Vec_Int_t *vLits, Vec_Str_t *vCnf, Vec_Int_t *vSatVars, int iPivotVar)
Definition acbMfs.c:139
Acb_NtkPrintVecWin
void Acb_NtkPrintVecWin(Acb_Ntk_t *p, Vec_Int_t *vVec, char *pName)
Definition acbMfs.c:444
Acb_ObjMarkTfo_rec
void Acb_ObjMarkTfo_rec(Acb_Ntk_t *p, int iObj, int nTfoLevMax, int nFanMax, Vec_Int_t *vMarked)
Definition acbMfs.c:531
Acb_NtkOptNode
int Acb_NtkOptNode(Acb_Mfs_t *p, int Pivot)
Definition acbMfs.c:1295
Acb_NtkCollectTfoSideInputs
Vec_Int_t * Acb_NtkCollectTfoSideInputs(Acb_Ntk_t *p, int Pivot, Vec_Int_t *vTfo)
Definition acbMfs.c:660
Acb_NtkCollectNewTfi1_rec
void Acb_NtkCollectNewTfi1_rec(Acb_Ntk_t *p, int iObj, Vec_Int_t *vTfiNew)
Definition acbMfs.c:687
Acb_ObjMarkTfo
Vec_Int_t * Acb_ObjMarkTfo(Acb_Ntk_t *p, Vec_Int_t *vDivs, int Pivot, int nTfoLevMax, int nFanMax)
Definition acbMfs.c:542
Acb_NtkDivisors
Vec_Int_t * Acb_NtkDivisors(Acb_Ntk_t *p, int Pivot, int nTfiLevMin, int fDelay)
Definition acbMfs.c:476
Acb_NtkCountRoots
int Acb_NtkCountRoots(Vec_Int_t *vWinObjs, int PivotVar)
Definition acbMfs.c:155
Acb_Mfs_t
struct Acb_Mfs_t_ Acb_Mfs_t
Definition acbMfs.c:1154
Acb_ObjDeriveTfo
void Acb_ObjDeriveTfo(Acb_Ntk_t *p, int Pivot, int nTfoLevMax, int nFanMax, Vec_Int_t **pvTfo, Vec_Int_t **pvRoots, int fDelay)
Definition acbMfs.c:632
Acb_DeriveCnfFromTruth
int Acb_DeriveCnfFromTruth(word Truth, int nVars, Vec_Int_t *vCover, Vec_Str_t *vCnf)
FUNCTION DEFINITIONS ///.
Definition acbMfs.c:53
Acb_NtkPrintVec
void Acb_NtkPrintVec(Acb_Ntk_t *p, Vec_Int_t *vVec, char *pName)
Definition acbMfs.c:428
Acb_ObjDeriveTfo_rec
void Acb_ObjDeriveTfo_rec(Acb_Ntk_t *p, int iObj, Vec_Int_t *vTfo, Vec_Int_t *vRoots, int fFirst)
Definition acbMfs.c:615
Acb_NtkWindowUndo
void Acb_NtkWindowUndo(Acb_Ntk_t *p, Vec_Int_t *vWin)
Definition acbMfs.c:277
Acb_NtkWindow2Solver
int Acb_NtkWindow2Solver(sat_solver *pSat, Cnf_Dat_t *pCnf, Vec_Int_t *vFlip, int PivotVar, int nDivs, int nTimes)
Definition acbMfs.c:298
Acb_ObjLabelTfo_rec
int Acb_ObjLabelTfo_rec(Acb_Ntk_t *p, int iObj, int nTfoLevMax, int nFanMax, int fFirst)
Definition acbMfs.c:572
Acb_NtkOpt
void Acb_NtkOpt(Acb_Ntk_t *pNtk, Acb_Par_t *pPars)
Definition acbMfs.c:1576
Acb_NtkWindow
Vec_Int_t * Acb_NtkWindow(Acb_Ntk_t *p, int Pivot, int nTfiLevs, int nTfoLevs, int nFanMax, int fDelay, int *pnDivs)
Definition acbMfs.c:789
Acb_NtkCollectNewTfi
Vec_Int_t * Acb_NtkCollectNewTfi(Acb_Ntk_t *p, int Pivot, Vec_Int_t *vDivs, Vec_Int_t *vSide, int *pnDivs)
Definition acbMfs.c:709
Acb_NtkCollectWindow
Vec_Int_t * Acb_NtkCollectWindow(Acb_Ntk_t *p, int Pivot, Vec_Int_t *vTfi, Vec_Int_t *vTfo, Vec_Int_t *vRoots)
Definition acbMfs.c:747
Acb_NtkPrintVec2
void Acb_NtkPrintVec2(Acb_Ntk_t *p, Vec_Int_t *vVec, char *pName)
Definition acbMfs.c:436
Acb_NtkFindSupp3
int Acb_NtkFindSupp3(Acb_Ntk_t *p, int Pivot, sat_solver *pSat, int nVars, int nDivs, Vec_Int_t *vWin, Vec_Int_t *vSupp, int nLutSize, int fDelay)
Definition acbMfs.c:1007
Acb_NtkCollectNewTfi2_rec
void Acb_NtkCollectNewTfi2_rec(Acb_Ntk_t *p, int iObj, Vec_Int_t *vTfiNew)
Definition acbMfs.c:698
Acb_DeriveCnfForNode
void Acb_DeriveCnfForNode(Acb_Ntk_t *p, int iObj, sat_solver *pSat, int OutVar)
Definition acbMfs.c:162
Acb_ObjLabelTfo
int Acb_ObjLabelTfo(Acb_Ntk_t *p, int Root, int nTfoLevMax, int nFanMax, int fDelay)
Definition acbMfs.c:595
Acb_NtkFindSupp1
int Acb_NtkFindSupp1(Acb_Ntk_t *p, int Pivot, sat_solver *pSat, int nVars, int nDivs, Vec_Int_t *vWin, Vec_Int_t *vSupp)
Definition acbMfs.c:914
Acb_MfsStart
Acb_Mfs_t * Acb_MfsStart(Acb_Ntk_t *pNtk, Acb_Par_t *pPars)
Definition acbMfs.c:1178
Acb_ComputeFunction
word Acb_ComputeFunction(sat_solver *pSat, int PivotVar, int FreeVar, Vec_Int_t *vDivVars, int fCompl)
Definition acbMfs.c:347
Acb_Par_t
typedefABC_NAMESPACE_HEADER_START struct Acb_Par_t_ Acb_Par_t
INCLUDES ///.
Definition acbPar.h:38
Acb_NtkUpdateLevelD
void Acb_NtkUpdateLevelD(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:376
Acb_Ntk_t
struct Acb_Ntk_t_ Acb_Ntk_t
Definition acb.h:47
Acb_ObjForEachFanout
#define Acb_ObjForEachFanout(p, iObj, iFanout, k)
Definition acb.h:378
Acb_NtkUpdateNode
void Acb_NtkUpdateNode(Acb_Ntk_t *p, int Pivot, word uTruth, Vec_Int_t *vSupp)
Definition acbUtil.c:681
Acb_NtkCreateNode
int Acb_NtkCreateNode(Acb_Ntk_t *p, word uTruth, Vec_Int_t *vSupp)
Definition acbUtil.c:636
Acb_NtkPrintNode
void Acb_NtkPrintNode(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:628
Acb_NtkUpdateTiming
void Acb_NtkUpdateTiming(Acb_Ntk_t *p, int iObj)
Definition acbUtil.c:570
Acb_NtkForEachNode
#define Acb_NtkForEachNode(p, i)
Definition acb.h:362
Acb_ObjForEachFaninFast
#define Acb_ObjForEachFaninFast(p, iObj, pFanins, iFanin, k)
Definition acb.h:375
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
Vec_Str_t
struct Vec_Str_t_ Vec_Str_t
Definition bblif.c:46
l_True
#define l_True
Definition bmcBmcS.c:35
l_False
#define l_False
Definition bmcBmcS.c:36
sat_solver_addclause
#define sat_solver_addclause
Definition cecSatG2.c:37
sat_solver
#define sat_solver
Definition cecSatG2.c:34
sat_solver_solve
#define sat_solver_solve
Definition cecSatG2.c:45
Cnf_DataCollectFlipLits
void Cnf_DataCollectFlipLits(Cnf_Dat_t *p, int iFlipVar, Vec_Int_t *vFlips)
Definition cnfMan.c:245
Cnf_Dat_t
struct Cnf_Dat_t_ Cnf_Dat_t
Definition cnf.h:52
Cnf_DataLiftAndFlipLits
void Cnf_DataLiftAndFlipLits(Cnf_Dat_t *p, int nVarsPlus, Vec_Int_t *vLits)
Definition cnfMan.c:254
Cnf_DataFree
void Cnf_DataFree(Cnf_Dat_t *p)
Definition cnfMan.c:207
Cnf_DataLift
void Cnf_DataLift(Cnf_Dat_t *p, int nVarsPlus)
Definition cnfMan.c:232
p
Cube * p
Definition exorList.c:222
Var
int Var
Definition exorList.c:228
Cube
struct cube Cube
Extra_PrintHex
void Extra_PrintHex(FILE *pFile, unsigned *pTruth, int nVars)
Definition extraUtilFile.c:643
word
unsigned __int64 word
DECLARATIONS ///.
Definition kitPerm.c:36
Kit_TruthIsop
int Kit_TruthIsop(unsigned *puTruth, int nVars, Vec_Int_t *vMemory, int fTryBoth)
Definition kitIsop.c:134
sat_solver_new
sat_solver * sat_solver_new(void)
Definition satSolver.c:1137
sat_solver_simplify
int sat_solver_simplify(sat_solver *s)
Definition satSolver.c:1515
sat_solver_restart
void sat_solver_restart(sat_solver *s)
Definition satSolver.c:1389
sat_solver_setnvars
void sat_solver_setnvars(sat_solver *s, int n)
Definition satSolver.c:1272
sat_solver_nvars
int sat_solver_nvars(sat_solver *s)
Definition satSolver.c:2369
sat_solver_delete
void sat_solver_delete(sat_solver *s)
Definition satSolver.c:1341
sat_solver_minimize_assumptions
int sat_solver_minimize_assumptions(sat_solver *s, int *pLits, int nLits, int nConfLimit)
Definition satSolver.c:2209
Acb_Mfs_t_
Definition acbMfs.c:1156
Acb_Mfs_t_::nOvers
int nOvers
Definition acbMfs.c:1168
Acb_Mfs_t_::timeCnf
abctime timeCnf
Definition acbMfs.c:1171
Acb_Mfs_t_::timeSol
abctime timeSol
Definition acbMfs.c:1172
Acb_Mfs_t_::timeSat
abctime timeSat
Definition acbMfs.c:1174
Acb_Mfs_t_::timeWin
abctime timeWin
Definition acbMfs.c:1173
Acb_Mfs_t_::vFlip
Vec_Int_t * vFlip
Definition acbMfs.c:1161
Acb_Mfs_t_::pPars
Acb_Par_t * pPars
Definition acbMfs.c:1158
Acb_Mfs_t_::nChanges
int nChanges[8]
Definition acbMfs.c:1167
Acb_Mfs_t_::nWinsAll
int nWinsAll
Definition acbMfs.c:1165
Acb_Mfs_t_::timeTotal
abctime timeTotal
Definition acbMfs.c:1170
Acb_Mfs_t_::nDivsAll
int nDivsAll
Definition acbMfs.c:1166
Acb_Mfs_t_::vValues
Vec_Int_t * vValues
Definition acbMfs.c:1162
Acb_Mfs_t_::nTwoNodes
int nTwoNodes
Definition acbMfs.c:1169
Acb_Mfs_t_::pSat
sat_solver * pSat[3]
Definition acbMfs.c:1159
Acb_Mfs_t_::vSupp
Vec_Int_t * vSupp
Definition acbMfs.c:1160
Acb_Mfs_t_::nNodes
int nNodes
Definition acbMfs.c:1163
Acb_Mfs_t_::nWins
int nWins
Definition acbMfs.c:1164
Acb_Mfs_t_::timeSatU
abctime timeSatU
Definition acbMfs.c:1175
Acb_Mfs_t_::timeSatS
abctime timeSatS
Definition acbMfs.c:1176
Acb_Mfs_t_::pNtk
Acb_Ntk_t * pNtk
Definition acbMfs.c:1157
Acb_Ntk_t_::vQue
Vec_Que_t * vQue
Definition acb.h:97
Cnf_Dat_t_::nVars
int nVars
Definition cnf.h:59
Cnf_Dat_t_::nLiterals
int nLiterals
Definition cnf.h:60
Cnf_Dat_t_::pClauses
int ** pClauses
Definition cnf.h:62
Cnf_Dat_t_::nClauses
int nClauses
Definition cnf.h:61
Vec_Str_t_::nSize
int nSize
Definition bblif.c:50
assert
#define assert(ex)
Definition util_old.h:213
memcpy
char * memcpy()
Vec_Bit_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Bit_t_ Vec_Bit_t
INCLUDES ///.
Definition vecBit.h:42
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Vec_IntForEachEntryStop
#define Vec_IntForEachEntryStop(vVec, Entry, i, Stop)
Definition vecInt.h:58
Vec_IntForEachEntryStart
#define Vec_IntForEachEntryStart(vVec, Entry, i, Start)
Definition vecInt.h:56
Vec_StrForEachEntry
#define Vec_StrForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecStr.h:54
Vec_Wec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wec_t_ Vec_Wec_t
INCLUDES ///.
Definition vecWec.h:42