fraCec.c 15.7 KB
Newer Older
Alan Mishchenko committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/**CFile****************************************************************

  FileName    [fraCec.c]

  SystemName  [ABC: Logic synthesis and verification system.]

  PackageName [New FRAIG package.]

  Synopsis    [CEC engined based on fraiging.]

  Author      [Alan Mishchenko]
  
  Affiliation [UC Berkeley]

  Date        [Ver. 1.0. Started - June 30, 2007.]

  Revision    [$Id: fraCec.c,v 1.00 2007/06/30 00:00:00 alanmi Exp $]

***********************************************************************/

#include "fra.h"
22 23
#include "sat/cnf/cnf.h"
#include "sat/bsat/satSolver2.h"
Alan Mishchenko committed
24

25 26 27
ABC_NAMESPACE_IMPL_START


Alan Mishchenko committed
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
////////////////////////////////////////////////////////////////////////
///                        DECLARATIONS                              ///
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
///                     FUNCTION DEFINITIONS                         ///
////////////////////////////////////////////////////////////////////////

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
47
int Fra_FraigSat( Aig_Man_t * pMan, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, int nLearnedStart, int nLearnedDelta, int nLearnedPerce, int fFlipBits, int fAndOuts, int fNewSolver, int fVerbose )
Alan Mishchenko committed
48
{
49 50 51 52
    if ( fNewSolver )
    {
        extern void * Cnf_DataWriteIntoSolver2( Cnf_Dat_t * p, int nFrames, int fInit );
        extern int    Cnf_DataWriteOrClause2( void * pSat, Cnf_Dat_t * pCnf );
Alan Mishchenko committed
53

54 55
        sat_solver2 * pSat;
        Cnf_Dat_t * pCnf;
56 57
        int status, RetValue;
        clock_t clk = clock();
58
        Vec_Int_t * vCiIds;
Alan Mishchenko committed
59

60 61
        assert( Aig_ManRegNum(pMan) == 0 );
        pMan->pData = NULL;
Alan Mishchenko committed
62

63
        // derive CNF
64 65
        pCnf = Cnf_Derive( pMan, Aig_ManCoNum(pMan) );
    //    pCnf = Cnf_DeriveSimple( pMan, Aig_ManCoNum(pMan) );
Alan Mishchenko committed
66

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
        if ( fFlipBits ) 
            Cnf_DataTranformPolarity( pCnf, 0 );

        // convert into SAT solver
        pSat = (sat_solver2 *)Cnf_DataWriteIntoSolver2( pCnf, 1, 0 );
        if ( pSat == NULL )
        {
            Cnf_DataFree( pCnf );
            return 1;
        }

        if ( fAndOuts )
        {
            // assert each output independently
            if ( !Cnf_DataWriteAndClauses( pSat, pCnf ) )
            {
                sat_solver2_delete( pSat );
                Cnf_DataFree( pCnf );
                return 1;
            }
        }
        else
        {
            // add the OR clause for the outputs
            if ( !Cnf_DataWriteOrClause2( pSat, pCnf ) )
            {
                sat_solver2_delete( pSat );
                Cnf_DataFree( pCnf );
                return 1;
            }
        }
        vCiIds = Cnf_DataCollectPiSatNums( pCnf, pMan );
Alan Mishchenko committed
99
        Cnf_DataFree( pCnf );
Alan Mishchenko committed
100 101


102 103 104 105 106 107
        printf( "Created SAT problem with %d variable and %d clauses. ", sat_solver2_nvars(pSat), sat_solver2_nclauses(pSat) );
        ABC_PRT( "Time", clock() - clk );

        // simplify the problem
        clk = clock();
        status = sat_solver2_simplify(pSat);
108 109
//        printf( "Simplified the problem to %d variables and %d clauses. ", sat_solver2_nvars(pSat), sat_solver2_nclauses(pSat) );
//        ABC_PRT( "Time", clock() - clk );
110
        if ( status == 0 )
Alan Mishchenko committed
111
        {
112 113 114
            Vec_IntFree( vCiIds );
            sat_solver2_delete( pSat );
    //        printf( "The problem is UNSATISFIABLE after simplification.\n" );
Alan Mishchenko committed
115 116
            return 1;
        }
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149

        // solve the miter
        clk = clock();
        if ( fVerbose )
            pSat->verbosity = 1;
        status = sat_solver2_solve( pSat, NULL, NULL, (ABC_INT64_T)nConfLimit, (ABC_INT64_T)nInsLimit, (ABC_INT64_T)0, (ABC_INT64_T)0 );
        if ( status == l_Undef )
        {
    //        printf( "The problem timed out.\n" );
            RetValue = -1;
        }
        else if ( status == l_True )
        {
    //        printf( "The problem is SATISFIABLE.\n" );
            RetValue = 0;
        }
        else if ( status == l_False )
        {
    //        printf( "The problem is UNSATISFIABLE.\n" );
            RetValue = 1;
        }
        else
            assert( 0 );

    //    Abc_Print( 1, "The number of conflicts = %6d.  ", (int)pSat->stats.conflicts );
    //    Abc_PrintTime( 1, "Solving time", clock() - clk );
 
        // if the problem is SAT, get the counterexample
        if ( status == l_True )
        {
            pMan->pData = Sat_Solver2GetModel( pSat, vCiIds->pArray, vCiIds->nSize );
        }
        // free the sat_solver2
150
        if ( fVerbose )
151 152 153 154 155 156
            Sat_Solver2PrintStats( stdout, pSat );
    //sat_solver2_store_write( pSat, "trace.cnf" );
    //sat_solver2_store_free( pSat );
        sat_solver2_delete( pSat );
        Vec_IntFree( vCiIds );
        return RetValue;
Alan Mishchenko committed
157 158 159
    }
    else
    {
160 161
        sat_solver * pSat;
        Cnf_Dat_t * pCnf;
162 163
        int status, RetValue;
        clock_t clk = clock();
164 165 166 167 168 169
        Vec_Int_t * vCiIds;

        assert( Aig_ManRegNum(pMan) == 0 );
        pMan->pData = NULL;

        // derive CNF
170 171
        pCnf = Cnf_Derive( pMan, Aig_ManCoNum(pMan) );
    //    pCnf = Cnf_DeriveSimple( pMan, Aig_ManCoNum(pMan) );
172 173 174 175 176 177 178

        if ( fFlipBits ) 
            Cnf_DataTranformPolarity( pCnf, 0 );

        // convert into SAT solver
        pSat = (sat_solver *)Cnf_DataWriteIntoSolver( pCnf, 1, 0 );
        if ( pSat == NULL )
Alan Mishchenko committed
179 180 181 182
        {
            Cnf_DataFree( pCnf );
            return 1;
        }
Alan Mishchenko committed
183

184 185 186 187 188 189
        if ( nLearnedStart )
            pSat->nLearntStart = nLearnedStart;
        if ( nLearnedDelta )
            pSat->nLearntDelta = nLearnedDelta;
        if ( nLearnedPerce )
            pSat->nLearntRatio = nLearnedPerce;
190 191
        if ( fVerbose )
            pSat->fVerbose = fVerbose;
Alan Mishchenko committed
192

193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
        if ( fAndOuts )
        {
            // assert each output independently
            if ( !Cnf_DataWriteAndClauses( pSat, pCnf ) )
            {
                sat_solver_delete( pSat );
                Cnf_DataFree( pCnf );
                return 1;
            }
        }
        else
        {
            // add the OR clause for the outputs
            if ( !Cnf_DataWriteOrClause( pSat, pCnf ) )
            {
                sat_solver_delete( pSat );
                Cnf_DataFree( pCnf );
                return 1;
            }
        }
        vCiIds = Cnf_DataCollectPiSatNums( pCnf, pMan );
        Cnf_DataFree( pCnf );
Alan Mishchenko committed
215 216


217 218
    //    printf( "Created SAT problem with %d variable and %d clauses. ", sat_solver_nvars(pSat), sat_solver_nclauses(pSat) );
    //    ABC_PRT( "Time", clock() - clk );
219

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
        // simplify the problem
        clk = clock();
        status = sat_solver_simplify(pSat);
    //    printf( "Simplified the problem to %d variables and %d clauses. ", sat_solver_nvars(pSat), sat_solver_nclauses(pSat) );
    //    ABC_PRT( "Time", clock() - clk );
        if ( status == 0 )
        {
            Vec_IntFree( vCiIds );
            sat_solver_delete( pSat );
    //        printf( "The problem is UNSATISFIABLE after simplification.\n" );
            return 1;
        }

        // solve the miter
        clk = clock();
235 236
//        if ( fVerbose )
//            pSat->verbosity = 1;
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
        status = sat_solver_solve( pSat, NULL, NULL, (ABC_INT64_T)nConfLimit, (ABC_INT64_T)nInsLimit, (ABC_INT64_T)0, (ABC_INT64_T)0 );
        if ( status == l_Undef )
        {
    //        printf( "The problem timed out.\n" );
            RetValue = -1;
        }
        else if ( status == l_True )
        {
    //        printf( "The problem is SATISFIABLE.\n" );
            RetValue = 0;
        }
        else if ( status == l_False )
        {
    //        printf( "The problem is UNSATISFIABLE.\n" );
            RetValue = 1;
        }
        else
            assert( 0 );

    //    Abc_Print( 1, "The number of conflicts = %6d.  ", (int)pSat->stats.conflicts );
    //    Abc_PrintTime( 1, "Solving time", clock() - clk );
Alan Mishchenko committed
258
 
259 260 261 262 263 264
        // if the problem is SAT, get the counterexample
        if ( status == l_True )
        {
            pMan->pData = Sat_SolverGetModel( pSat, vCiIds->pArray, vCiIds->nSize );
        }
        // free the sat_solver
265
        if ( fVerbose )
266 267 268 269 270 271
            Sat_SolverPrintStats( stdout, pSat );
    //sat_solver_store_write( pSat, "trace.cnf" );
    //sat_solver_store_free( pSat );
        sat_solver_delete( pSat );
        Vec_IntFree( vCiIds );
        return RetValue;
Alan Mishchenko committed
272 273 274 275 276 277 278 279 280 281 282 283 284 285
    }
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Alan Mishchenko committed
286
int Fra_FraigCec( Aig_Man_t ** ppAig, int nConfLimit, int fVerbose )
Alan Mishchenko committed
287
{
Alan Mishchenko committed
288 289 290
    int nBTLimitStart =        300;   // starting SAT run
    int nBTLimitFirst =          2;   // first fraiging iteration
    int nBTLimitLast  = nConfLimit;   // the last-gasp SAT run
Alan Mishchenko committed
291 292 293

    Fra_Par_t Params, * pParams = &Params;
    Aig_Man_t * pAig = *ppAig, * pTemp;
294 295
    int i, RetValue;
    clock_t clk;
Alan Mishchenko committed
296 297 298 299 300 301 302 303

    // report the original miter
    if ( fVerbose )
    {
        printf( "Original miter:   Nodes = %6d.\n", Aig_ManNodeNum(pAig) );
    }
    RetValue = Fra_FraigMiterStatus( pAig );
//    assert( RetValue == -1 );
Alan Mishchenko committed
304
    if ( RetValue == 0 )
Alan Mishchenko committed
305
    {
306 307
        pAig->pData = ABC_ALLOC( int, Aig_ManCiNum(pAig) );
        memset( pAig->pData, 0, sizeof(int) * Aig_ManCiNum(pAig) );
Alan Mishchenko committed
308
        return RetValue;
Alan Mishchenko committed
309
    }
Alan Mishchenko committed
310 311 312

    // if SAT only, solve without iteration
clk = clock();
313
    RetValue = Fra_FraigSat( pAig, (ABC_INT64_T)2*nBTLimitStart, (ABC_INT64_T)0, 0, 0, 0, 1, 0, 0, 0 );
Alan Mishchenko committed
314 315 316
    if ( fVerbose )
    {
        printf( "Initial SAT:      Nodes = %6d.  ", Aig_ManNodeNum(pAig) );
Alan Mishchenko committed
317
ABC_PRT( "Time", clock() - clk );
Alan Mishchenko committed
318 319 320 321 322 323
    }
    if ( RetValue >= 0 )
        return RetValue;

    // duplicate the AIG
clk = clock();
Alan Mishchenko committed
324
    pAig = Dar_ManRwsat( pTemp = pAig, 1, 0 );
Alan Mishchenko committed
325 326 327 328
    Aig_ManStop( pTemp );
    if ( fVerbose )
    {
        printf( "Rewriting:        Nodes = %6d.  ", Aig_ManNodeNum(pAig) );
Alan Mishchenko committed
329
ABC_PRT( "Time", clock() - clk );
Alan Mishchenko committed
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
    }

    // perform the loop
    Fra_ParamsDefault( pParams );
    pParams->nBTLimitNode = nBTLimitFirst;
    pParams->nBTLimitMiter = nBTLimitStart;
    pParams->fDontShowBar = 1;
    pParams->fProve = 1;
    for ( i = 0; i < 6; i++ )
    {
//printf( "Running fraiging with %d BTnode and %d BTmiter.\n", pParams->nBTLimitNode, pParams->nBTLimitMiter );
        // run fraiging
clk = clock();
        pAig = Fra_FraigPerform( pTemp = pAig, pParams );
        Aig_ManStop( pTemp );
        if ( fVerbose )
        {
            printf( "Fraiging (i=%d):   Nodes = %6d.  ", i+1, Aig_ManNodeNum(pAig) );
Alan Mishchenko committed
348
ABC_PRT( "Time", clock() - clk );
Alan Mishchenko committed
349 350 351 352 353 354 355 356 357 358 359 360 361 362
        }

        // check the miter status
        RetValue = Fra_FraigMiterStatus( pAig );
        if ( RetValue >= 0 )
            break;

        // perform rewriting
clk = clock();
        pAig = Dar_ManRewriteDefault( pTemp = pAig );
        Aig_ManStop( pTemp );
        if ( fVerbose )
        {
            printf( "Rewriting:        Nodes = %6d.  ", Aig_ManNodeNum(pAig) );
Alan Mishchenko committed
363
ABC_PRT( "Time", clock() - clk );
Alan Mishchenko committed
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
        } 

        // check the miter status
        RetValue = Fra_FraigMiterStatus( pAig );
        if ( RetValue >= 0 )
            break;
        // try simulation

        // set the parameters for the next run
        pParams->nBTLimitNode = 8 * pParams->nBTLimitNode;
        pParams->nBTLimitMiter = 2 * pParams->nBTLimitMiter;
    }

    // if still unsolved try last gasp
    if ( RetValue == -1 )
    {
clk = clock();
381
        RetValue = Fra_FraigSat( pAig, (ABC_INT64_T)nBTLimitLast, (ABC_INT64_T)0, 0, 0, 0, 1, 0, 0, 0 );
Alan Mishchenko committed
382 383 384
        if ( fVerbose )
        {
            printf( "Final SAT:            Nodes = %6d.  ", Aig_ManNodeNum(pAig) );
Alan Mishchenko committed
385
ABC_PRT( "Time", clock() - clk );
Alan Mishchenko committed
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
        }
    }

    *ppAig = pAig;
    return RetValue;
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Alan Mishchenko committed
404
int Fra_FraigCecPartitioned( Aig_Man_t * pMan1, Aig_Man_t * pMan2, int nConfLimit, int nPartSize, int fSmart, int fVerbose )
Alan Mishchenko committed
405 406 407 408 409
{
    Aig_Man_t * pAig;
    Vec_Ptr_t * vParts;
    int i, RetValue = 1, nOutputs;
    // create partitions
Alan Mishchenko committed
410
    vParts = Aig_ManMiterPartitioned( pMan1, pMan2, nPartSize, fSmart );
Alan Mishchenko committed
411 412
    // solve the partitions
    nOutputs = -1;
413
    Vec_PtrForEachEntry( Aig_Man_t *, vParts, pAig, i )
Alan Mishchenko committed
414 415 416
    {
        nOutputs++;
        if ( fVerbose )
Alan Mishchenko committed
417
        {
Alan Mishchenko committed
418
            printf( "Verifying part %4d  (out of %4d)  PI = %5d. PO = %5d. And = %6d. Lev = %4d.\r", 
419
                i+1, Vec_PtrSize(vParts), Aig_ManCiNum(pAig), Aig_ManCoNum(pAig), 
Alan Mishchenko committed
420
                Aig_ManNodeNum(pAig), Aig_ManLevelNum(pAig) );
Alan Mishchenko committed
421 422
            fflush( stdout );
        }
Alan Mishchenko committed
423 424 425 426 427
        RetValue = Fra_FraigMiterStatus( pAig );
        if ( RetValue == 1 )
            continue;
        if ( RetValue == 0 )
            break;
Alan Mishchenko committed
428
        RetValue = Fra_FraigCec( &pAig, nConfLimit, 0 );
Alan Mishchenko committed
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
        Vec_PtrWriteEntry( vParts, i, pAig );
        if ( RetValue == 1 )
            continue;
        if ( RetValue == 0 )
            break;
        break;
    }
    // clear the result
    if ( fVerbose )
    {
        printf( "                                                                                          \r" );
        fflush( stdout );
    }
    // report the timeout
    if ( RetValue == -1 )
    {
        printf( "Timed out after verifying %d partitions (out of %d).\n", nOutputs, Vec_PtrSize(vParts) );
        fflush( stdout );
    }
Alan Mishchenko committed
448
    // free intermediate results
449
    Vec_PtrForEachEntry( Aig_Man_t *, vParts, pAig, i )
Alan Mishchenko committed
450 451 452 453 454
        Aig_ManStop( pAig );
    Vec_PtrFree( vParts );
    return RetValue;
}

Alan Mishchenko committed
455 456 457 458 459 460 461 462 463 464 465
/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Alan Mishchenko committed
466
int Fra_FraigCecTop( Aig_Man_t * pMan1, Aig_Man_t * pMan2, int nConfLimit, int nPartSize, int fSmart, int fVerbose )
Alan Mishchenko committed
467
{
Alan Mishchenko committed
468
    Aig_Man_t * pTemp;
Alan Mishchenko committed
469
    //Abc_NtkDarCec( pNtk1, pNtk2, fPartition, fVerbose );
470 471
    int RetValue;
    clock_t clkTotal = clock();
Alan Mishchenko committed
472

473
    if ( Aig_ManCiNum(pMan1) != Aig_ManCiNum(pMan1) )
Alan Mishchenko committed
474 475 476 477
    {
        printf( "Abc_CommandAbc8Cec(): Miters have different number of PIs.\n" );
        return 0;
    }
478
    if ( Aig_ManCoNum(pMan1) != Aig_ManCoNum(pMan1) )
Alan Mishchenko committed
479 480 481 482
    {
        printf( "Abc_CommandAbc8Cec(): Miters have different number of POs.\n" );
        return 0;
    }
483 484
    assert( Aig_ManCiNum(pMan1) == Aig_ManCiNum(pMan1) );
    assert( Aig_ManCoNum(pMan1) == Aig_ManCoNum(pMan1) );
Alan Mishchenko committed
485

Alan Mishchenko committed
486 487 488 489 490 491 492 493 494 495
    // make sure that the first miter has more nodes
    if ( Aig_ManNodeNum(pMan1) < Aig_ManNodeNum(pMan2) )
    {
        pTemp = pMan1;
        pMan1 = pMan2;
        pMan2 = pTemp;
    }
    assert( Aig_ManNodeNum(pMan1) >= Aig_ManNodeNum(pMan2) );

    if ( nPartSize )
Alan Mishchenko committed
496
        RetValue = Fra_FraigCecPartitioned( pMan1, pMan2, nConfLimit, nPartSize, fSmart, fVerbose );
Alan Mishchenko committed
497
    else // no partitioning
498
        RetValue = Fra_FraigCecPartitioned( pMan1, pMan2, nConfLimit, Aig_ManCoNum(pMan1), 0, fVerbose );
Alan Mishchenko committed
499 500 501 502 503

    // report the miter
    if ( RetValue == 1 )
    {
        printf( "Networks are equivalent.   " );
Alan Mishchenko committed
504
ABC_PRT( "Time", clock() - clkTotal );
Alan Mishchenko committed
505 506 507 508
    }
    else if ( RetValue == 0 )
    {
        printf( "Networks are NOT EQUIVALENT.   " );
Alan Mishchenko committed
509
ABC_PRT( "Time", clock() - clkTotal );
Alan Mishchenko committed
510 511 512 513
    }
    else
    {
        printf( "Networks are UNDECIDED.   " );
Alan Mishchenko committed
514
ABC_PRT( "Time", clock() - clkTotal );
Alan Mishchenko committed
515 516 517 518 519
    }
    fflush( stdout );
    return RetValue;
}

Alan Mishchenko committed
520 521 522 523 524 525

////////////////////////////////////////////////////////////////////////
///                       END OF FILE                                ///
////////////////////////////////////////////////////////////////////////


526 527
ABC_NAMESPACE_IMPL_END