satProof2.h File Reference

#include "misc/vec/vec.h"

Go to the source code of this file.

Data Structures
struct	Prf_Man_t_

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Prf_Man_t_	Prf_Man_t
	INCLUDES ///. More...

Functions
static int	Prf_BitWordNum (int nWidth)
	GLOBAL VARIABLES ///. More...
static int	Prf_ManSize (Prf_Man_t *p)
static void	Prf_ManClearNewInfo (Prf_Man_t *p)
static word *	Prf_ManClauseInfo (Prf_Man_t *p, int Id)
static Prf_Man_t *	Prf_ManAlloc ()
	FUNCTION DECLARATIONS ///. More...
static void	Prf_ManStop (Prf_Man_t *p)
static void	Prf_ManStopP (Prf_Man_t **p)
static double	Prf_ManMemory (Prf_Man_t *p)
static void	Prf_ManRestart (Prf_Man_t *p, Vec_Int_t *vId2Pr, int iFirst, int nWidth)
static void	Prf_ManGrow (Prf_Man_t *p, int nWidth)
static void	Prf_ManShrink (Prf_Man_t *p, int iClause)
static void	Prf_ManAddSaved (Prf_Man_t *p, int i, int iNew)
static void	Prf_ManCompact (Prf_Man_t *p, int iNew)
static void	Prf_ManChainResolve (Prf_Man_t *p, clause *c)
static void	Prf_ManChainStart (Prf_Man_t *p, clause *c)
static int	Prf_ManChainStop (Prf_Man_t *p)
static Vec_Int_t *	Prf_ManUnsatCore (Prf_Man_t *p)

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct Prf_Man_t_ Prf_Man_t

INCLUDES ///.

CFile****************************************************************

FileName [satProof2.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [SAT solver.]

Synopsis [Proof logging.]

Author [Alan Mishchenko alanm.nosp@m.i@ee.nosp@m.cs.be.nosp@m.rkel.nosp@m.ey.ed.nosp@m.u]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - January 1, 2004.]

Revision [

Id:

satProof2.h,v 1.0 2004/01/01 1:00:00 alanmi Exp

]PARAMETERS ///STRUCTURE DEFINITIONS ///

Definition at line 40 of file satProof2.h.

Function Documentation

static int Prf_BitWordNum ( int  nWidth )

inlinestatic

GLOBAL VARIABLES ///.

MACRO DEFINITIONS ///

Definition at line 60 of file satProof2.h.

{ return (nWidth >> 6) + ((nWidth & 63) > 0);                           }

static void Prf_ManAddSaved ( Prf_Man_t *  p, int  i, int  iNew  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 175 of file satProof2.h.

{
    assert( p->iFirst >= 0 );
    if ( i < p->iFirst )
        return;
    if ( Vec_IntSize(p->vSaved) == 0 )
    {
        assert( p->iFirst2 == -1 );
        p->iFirst2 = iNew;
    }
    Vec_IntPush( p->vSaved, i );
}

static Prf_Man_t* Prf_ManAlloc ( )

inlinestatic

FUNCTION DECLARATIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 81 of file satProof2.h.

{
    Prf_Man_t * p;
    p = ABC_CALLOC( Prf_Man_t, 1 );
    p->iFirst  = -1;
    p->iFirst2 = -1;
    p->vInfo   = Vec_WrdAlloc( 1000 );
    p->vSaved  = Vec_IntAlloc( 1000 );
    return p;
}

static void Prf_ManChainResolve ( Prf_Man_t *  p, clause *  c  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 222 of file satProof2.h.

{
    assert( p->iFirst >= 0 );
    assert( p->pInfo != NULL );
    // add to proof info
    if ( c->lrn ) // learned clause
    {
        if ( clause_id(c) >= p->iFirst )
        {
            word * pProofStart;
            int w;
            assert( clause_id(c) - p->iFirst >= 0 );
            assert( clause_id(c) - p->iFirst < Prf_ManSize(p) ); 
            pProofStart = Prf_ManClauseInfo( p, clause_id(c) - p->iFirst );
            for ( w = 0; w < p->nWords; w++ )
                p->pInfo[w] |= pProofStart[w];
        }
    }
    else // problem clause
    {  
        if ( clause_id(c) >= 0 ) // has proof ID
        {
            int Entry;
            if ( p->vId2Pr == NULL )
                Entry = clause_id(c);
            else
                Entry = Vec_IntEntry( p->vId2Pr, clause_id(c) );
            if ( Entry >= 0 )
            {
                assert( Entry < 64 * p->nWords );
                Abc_InfoSetBit( (unsigned *)p->pInfo, Entry );
            }
        }
    }
}

static void Prf_ManChainStart ( Prf_Man_t *  p, clause *  c  )

inlinestatic

Definition at line 257 of file satProof2.h.

{
    assert( p->iFirst >= 0 );
    // prepare info for new clause
    Prf_ManClearNewInfo( p );
    // get pointer to the proof
    assert( p->pInfo == NULL );
    p->pInfo = Prf_ManClauseInfo( p, Prf_ManSize(p)-1 );
    // add to proof info
    Prf_ManChainResolve( p, c );
}

static int Prf_ManChainStop ( Prf_Man_t *  p )

inlinestatic

Definition at line 268 of file satProof2.h.

{
    assert( p->pInfo != NULL );
    p->pInfo = NULL;
    return 0;
}

static word* Prf_ManClauseInfo ( Prf_Man_t *  p, int  Id  )

inlinestatic

Definition at line 63 of file satProof2.h.

{ return Vec_WrdEntryP( p->vInfo, Id * p->nWords );                     }

static void Prf_ManClearNewInfo ( Prf_Man_t *  p )

inlinestatic

Definition at line 62 of file satProof2.h.

{ int w; for ( w = 0; w < p->nWords; w++ ) Vec_WrdPush( p->vInfo, 0 );  }

static void Prf_ManCompact ( Prf_Man_t *  p, int  iNew  )

inlinestatic

Definition at line 187 of file satProof2.h.

{
    int i, w, k = 0, Entry, nSize;
    assert( p->iFirst >= 0 );
    assert( p->pInfo == NULL );
    nSize = Prf_ManSize( p );
    Vec_IntForEachEntry( p->vSaved, Entry, i )
    {
        assert( Entry - p->iFirst >= 0 && Entry - p->iFirst < nSize );
        p->pInfo = Prf_ManClauseInfo( p, Entry - p->iFirst );
        for ( w = 0; w < p->nWords; w++ )
            Vec_WrdWriteEntry( p->vInfo, k++, p->pInfo[w] );
    }
    Vec_WrdShrink( p->vInfo, k );
    Vec_IntClear( p->vSaved );
    p->pInfo = NULL;
    // update first
    if ( p->iFirst2 == -1 )
        p->iFirst = iNew;
    else
        p->iFirst = p->iFirst2;
    p->iFirst2 = -1;
}

static void Prf_ManGrow ( Prf_Man_t *  p, int  nWidth  )

inlinestatic

Definition at line 129 of file satProof2.h.

{
    Vec_Wrd_t * vInfoNew;
    int i, w, nSize, nWordsNew;
    assert( p->iFirst >= 0 );
    assert( p->pInfo == NULL );
    if ( nWidth < 64 * p->nWords )
        return;
    // get word count after resizing
    nWordsNew = Abc_MaxInt( Prf_BitWordNum(nWidth), 2 * p->nWords );
    // remap the entries
    nSize = Prf_ManSize( p );
    vInfoNew = Vec_WrdAlloc( (nSize + 1000) * nWordsNew );
    for ( i = 0; i < nSize; i++ )
    {
        p->pInfo = Prf_ManClauseInfo( p, i );
        for ( w = 0; w < p->nWords; w++ )
            Vec_WrdPush( vInfoNew, p->pInfo[w] );
        for ( ; w < nWordsNew; w++ )
            Vec_WrdPush( vInfoNew, 0 );
    }
    Vec_WrdFree( p->vInfo );
    p->vInfo = vInfoNew;
    p->nWords = nWordsNew;
    p->pInfo = NULL;

}

static double Prf_ManMemory ( Prf_Man_t *  p )

inlinestatic

Definition at line 104 of file satProof2.h.

{
    return Vec_WrdMemory(p->vInfo) + Vec_IntMemory(p->vSaved) + sizeof(Prf_Man_t);
}

static void Prf_ManRestart ( Prf_Man_t *  p, Vec_Int_t *  vId2Pr, int  iFirst, int  nWidth  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 120 of file satProof2.h.

{
    assert( p->iFirst == -1 );
    p->iFirst = iFirst;
    p->nWords = Prf_BitWordNum( nWidth );
    p->vId2Pr = vId2Pr;
    p->pInfo  = NULL;
    Vec_WrdClear( p->vInfo );
}

static void Prf_ManShrink ( Prf_Man_t *  p, int  iClause  )

inlinestatic

Definition at line 156 of file satProof2.h.

{
    assert( p->iFirst >= 0 );
    assert( iClause - p->iFirst >= 0 );
    assert( iClause - p->iFirst < Prf_ManSize(p) ); 
    Vec_WrdShrink( p->vInfo, (iClause - p->iFirst) * p->nWords );
}

static int Prf_ManSize ( Prf_Man_t *  p )

inlinestatic

Definition at line 61 of file satProof2.h.

{ return Vec_WrdSize( p->vInfo ) / p->nWords;                           }

static void Prf_ManStop ( Prf_Man_t *  p )

inlinestatic

Definition at line 91 of file satProof2.h.

{
    if ( p == NULL )
        return;
    Vec_IntFree( p->vSaved );
    Vec_WrdFree( p->vInfo );
    ABC_FREE( p );
}

static void Prf_ManStopP ( Prf_Man_t **  p )

inlinestatic

Definition at line 99 of file satProof2.h.

{
    Prf_ManStop( *p );
    *p = NULL;
}

static Vec_Int_t* Prf_ManUnsatCore ( Prf_Man_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 287 of file satProof2.h.

{
    Vec_Int_t * vCore;
    int i, Entry;
    assert( p->iFirst >= 0 );
    assert( p->pInfo == NULL );
    assert( Prf_ManSize(p) > 0 );
    vCore = Vec_IntAlloc( 64 * p->nWords );
    p->pInfo = Prf_ManClauseInfo( p, Prf_ManSize(p)-1 );
    if ( p->vId2Pr == NULL )
    {
        for ( i = 0; i < 64 * p->nWords; i++ )
            if ( Abc_InfoHasBit( (unsigned *)p->pInfo, i ) )
                Vec_IntPush( vCore, i );
    }
    else
    {
        Vec_IntForEachEntry( p->vId2Pr, Entry, i )
        {
            if ( Entry < 0 )
                continue;
            assert( Entry < 64 * p->nWords );
            if ( Abc_InfoHasBit( (unsigned *)p->pInfo, Entry ) )
                Vec_IntPush( vCore, i );
        }
    }
    p->pInfo = NULL;
    Vec_IntSort( vCore, 1 );
    return vCore;
}