hop.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "misc/vec/vec.h"

Go to the source code of this file.

Data Structures
struct	Hop_Obj_t_
struct	Hop_Man_t_

Macros
#define	Hop_ManForEachPi(p, pObj, i)   Vec_PtrForEachEntry( Hop_Obj_t *, p->vPis, pObj, i )
	ITERATORS ///. More...
#define	Hop_ManForEachPo(p, pObj, i)   Vec_PtrForEachEntry( Hop_Obj_t *, p->vPos, pObj, i )
#define	Hop_ManForEachNode(p, pObj, i)

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Hop_Man_t_	Hop_Man_t
	INCLUDES ///. More...
typedef struct Hop_Obj_t_	Hop_Obj_t
typedef int	Hop_Edge_t

Enumerations
enum	Hop_Type_t {   AIG_NONE, AIG_CONST1, AIG_PI, AIG_PO,   AIG_AND, AIG_EXOR, AIG_VOID }

Functions
void	Hop_ManAddMemory (Hop_Man_t *p)
	MACRO DEFINITIONS ///. More...
static int	Hop_BitWordNum (int nBits)
static int	Hop_TruthWordNum (int nVars)
static int	Hop_InfoHasBit (unsigned *p, int i)
static void	Hop_InfoSetBit (unsigned *p, int i)
static void	Hop_InfoXorBit (unsigned *p, int i)
static int	Hop_Base2Log (unsigned n)
static int	Hop_Base10Log (unsigned n)
static Hop_Obj_t *	Hop_Regular (Hop_Obj_t *p)
static Hop_Obj_t *	Hop_Not (Hop_Obj_t *p)
static Hop_Obj_t *	Hop_NotCond (Hop_Obj_t *p, int c)
static int	Hop_IsComplement (Hop_Obj_t *p)
static Hop_Obj_t *	Hop_ManConst0 (Hop_Man_t *p)
static Hop_Obj_t *	Hop_ManConst1 (Hop_Man_t *p)
static Hop_Obj_t *	Hop_ManGhost (Hop_Man_t *p)
static Hop_Obj_t *	Hop_ManPi (Hop_Man_t *p, int i)
static Hop_Obj_t *	Hop_ManPo (Hop_Man_t *p, int i)
static Hop_Obj_t *	Hop_ManObj (Hop_Man_t *p, int i)
static Hop_Edge_t	Hop_EdgeCreate (int Id, int fCompl)
static int	Hop_EdgeId (Hop_Edge_t Edge)
static int	Hop_EdgeIsComplement (Hop_Edge_t Edge)
static Hop_Edge_t	Hop_EdgeRegular (Hop_Edge_t Edge)
static Hop_Edge_t	Hop_EdgeNot (Hop_Edge_t Edge)
static Hop_Edge_t	Hop_EdgeNotCond (Hop_Edge_t Edge, int fCond)
static int	Hop_ManPiNum (Hop_Man_t *p)
static int	Hop_ManPoNum (Hop_Man_t *p)
static int	Hop_ManAndNum (Hop_Man_t *p)
static int	Hop_ManExorNum (Hop_Man_t *p)
static int	Hop_ManNodeNum (Hop_Man_t *p)
static int	Hop_ManGetCost (Hop_Man_t *p)
static int	Hop_ManObjNum (Hop_Man_t *p)
static Hop_Type_t	Hop_ObjType (Hop_Obj_t *pObj)
static int	Hop_ObjIsNone (Hop_Obj_t *pObj)
static int	Hop_ObjIsConst1 (Hop_Obj_t *pObj)
static int	Hop_ObjIsPi (Hop_Obj_t *pObj)
static int	Hop_ObjIsPo (Hop_Obj_t *pObj)
static int	Hop_ObjIsAnd (Hop_Obj_t *pObj)
static int	Hop_ObjIsExor (Hop_Obj_t *pObj)
static int	Hop_ObjIsNode (Hop_Obj_t *pObj)
static int	Hop_ObjIsTerm (Hop_Obj_t *pObj)
static int	Hop_ObjIsHash (Hop_Obj_t *pObj)
static int	Hop_ObjIsMarkA (Hop_Obj_t *pObj)
static void	Hop_ObjSetMarkA (Hop_Obj_t *pObj)
static void	Hop_ObjClearMarkA (Hop_Obj_t *pObj)
static void	Hop_ObjSetTravId (Hop_Obj_t *pObj, int TravId)
static void	Hop_ObjSetTravIdCurrent (Hop_Man_t *p, Hop_Obj_t *pObj)
static void	Hop_ObjSetTravIdPrevious (Hop_Man_t *p, Hop_Obj_t *pObj)
static int	Hop_ObjIsTravIdCurrent (Hop_Man_t *p, Hop_Obj_t *pObj)
static int	Hop_ObjIsTravIdPrevious (Hop_Man_t *p, Hop_Obj_t *pObj)
static int	Hop_ObjTravId (Hop_Obj_t *pObj)
static int	Hop_ObjPhase (Hop_Obj_t *pObj)
static int	Hop_ObjRefs (Hop_Obj_t *pObj)
static void	Hop_ObjRef (Hop_Obj_t *pObj)
static void	Hop_ObjDeref (Hop_Obj_t *pObj)
static void	Hop_ObjClearRef (Hop_Obj_t *pObj)
static int	Hop_ObjFaninC0 (Hop_Obj_t *pObj)
static int	Hop_ObjFaninC1 (Hop_Obj_t *pObj)
static Hop_Obj_t *	Hop_ObjFanin0 (Hop_Obj_t *pObj)
static Hop_Obj_t *	Hop_ObjFanin1 (Hop_Obj_t *pObj)
static Hop_Obj_t *	Hop_ObjChild0 (Hop_Obj_t *pObj)
static Hop_Obj_t *	Hop_ObjChild1 (Hop_Obj_t *pObj)
static Hop_Obj_t *	Hop_ObjChild0Copy (Hop_Obj_t *pObj)
static Hop_Obj_t *	Hop_ObjChild1Copy (Hop_Obj_t *pObj)
static int	Hop_ObjChild0CopyI (Hop_Obj_t *pObj)
static int	Hop_ObjChild1CopyI (Hop_Obj_t *pObj)
static int	Hop_ObjLevel (Hop_Obj_t *pObj)
static int	Hop_ObjLevelNew (Hop_Obj_t *pObj)
static int	Hop_ObjPhaseCompl (Hop_Obj_t *pObj)
static void	Hop_ObjClean (Hop_Obj_t *pObj)
static int	Hop_ObjWhatFanin (Hop_Obj_t *pObj, Hop_Obj_t *pFanin)
static int	Hop_ObjFanoutC (Hop_Obj_t *pObj, Hop_Obj_t *pFanout)
static Hop_Obj_t *	Hop_ObjCreateGhost (Hop_Man_t *p, Hop_Obj_t *p0, Hop_Obj_t *p1, Hop_Type_t Type)
static Hop_Obj_t *	Hop_ManFetchMemory (Hop_Man_t *p)
static void	Hop_ManRecycleMemory (Hop_Man_t *p, Hop_Obj_t *pEntry)
Hop_Man_t *	Hop_ManBalance (Hop_Man_t *p, int fUpdateLevel)
	FUNCTION DECLARATIONS ///. More...
Hop_Obj_t *	Hop_NodeBalanceBuildSuper (Hop_Man_t *p, Vec_Ptr_t *vSuper, Hop_Type_t Type, int fUpdateLevel)
int	Hop_ManCheck (Hop_Man_t *p)
	DECLARATIONS ///. More...
Vec_Ptr_t *	Hop_ManDfs (Hop_Man_t *p)
Vec_Ptr_t *	Hop_ManDfsNode (Hop_Man_t *p, Hop_Obj_t *pNode)
int	Hop_ManCountLevels (Hop_Man_t *p)
void	Hop_ManCreateRefs (Hop_Man_t *p)
int	Hop_DagSize (Hop_Obj_t *pObj)
int	Hop_ObjFanoutCount (Hop_Obj_t *pObj, Hop_Obj_t *pPivot)
void	Hop_ConeUnmark_rec (Hop_Obj_t *pObj)
Hop_Obj_t *	Hop_Transfer (Hop_Man_t *pSour, Hop_Man_t *pDest, Hop_Obj_t *pObj, int nVars)
Hop_Obj_t *	Hop_Compose (Hop_Man_t *p, Hop_Obj_t *pRoot, Hop_Obj_t *pFunc, int iVar)
Hop_Obj_t *	Hop_Complement (Hop_Man_t *p, Hop_Obj_t *pRoot, int iVar)
Hop_Obj_t *	Hop_Remap (Hop_Man_t *p, Hop_Obj_t *pRoot, unsigned uSupp, int nVars)
Hop_Obj_t *	Hop_Permute (Hop_Man_t *p, Hop_Obj_t *pRoot, int nRootVars, int *pPermute)
Hop_Man_t *	Hop_ManStart ()
	DECLARATIONS ///. More...
Hop_Man_t *	Hop_ManDup (Hop_Man_t *p)
void	Hop_ManStop (Hop_Man_t *p)
int	Hop_ManCleanup (Hop_Man_t *p)
void	Hop_ManPrintStats (Hop_Man_t *p)
void	Hop_ManStartMemory (Hop_Man_t *p)
	FUNCTION DEFINITIONS ///. More...
void	Hop_ManStopMemory (Hop_Man_t *p)
Hop_Obj_t *	Hop_ObjCreatePi (Hop_Man_t *p)
	DECLARATIONS ///. More...
Hop_Obj_t *	Hop_ObjCreatePo (Hop_Man_t *p, Hop_Obj_t *pDriver)
Hop_Obj_t *	Hop_ObjCreate (Hop_Man_t *p, Hop_Obj_t *pGhost)
void	Hop_ObjConnect (Hop_Man_t *p, Hop_Obj_t *pObj, Hop_Obj_t *pFan0, Hop_Obj_t *pFan1)
void	Hop_ObjDisconnect (Hop_Man_t *p, Hop_Obj_t *pObj)
void	Hop_ObjDelete (Hop_Man_t *p, Hop_Obj_t *pObj)
void	Hop_ObjDelete_rec (Hop_Man_t *p, Hop_Obj_t *pObj)
Hop_Obj_t *	Hop_ObjRepr (Hop_Obj_t *pObj)
void	Hop_ObjCreateChoice (Hop_Obj_t *pOld, Hop_Obj_t *pNew)
Hop_Obj_t *	Hop_IthVar (Hop_Man_t *p, int i)
	FUNCTION DEFINITIONS ///. More...
Hop_Obj_t *	Hop_Oper (Hop_Man_t *p, Hop_Obj_t *p0, Hop_Obj_t *p1, Hop_Type_t Type)
Hop_Obj_t *	Hop_And (Hop_Man_t *p, Hop_Obj_t *p0, Hop_Obj_t *p1)
Hop_Obj_t *	Hop_Or (Hop_Man_t *p, Hop_Obj_t *p0, Hop_Obj_t *p1)
Hop_Obj_t *	Hop_Exor (Hop_Man_t *p, Hop_Obj_t *p0, Hop_Obj_t *p1)
Hop_Obj_t *	Hop_Mux (Hop_Man_t *p, Hop_Obj_t *pC, Hop_Obj_t *p1, Hop_Obj_t *p0)
Hop_Obj_t *	Hop_Maj (Hop_Man_t *p, Hop_Obj_t *pA, Hop_Obj_t *pB, Hop_Obj_t *pC)
Hop_Obj_t *	Hop_Miter (Hop_Man_t *p, Vec_Ptr_t *vPairs)
Hop_Obj_t *	Hop_CreateAnd (Hop_Man_t *p, int nVars)
Hop_Obj_t *	Hop_CreateOr (Hop_Man_t *p, int nVars)
Hop_Obj_t *	Hop_CreateExor (Hop_Man_t *p, int nVars)
Hop_Obj_t *	Hop_TableLookup (Hop_Man_t *p, Hop_Obj_t *pGhost)
	FUNCTION DEFINITIONS ///. More...
void	Hop_TableInsert (Hop_Man_t *p, Hop_Obj_t *pObj)
void	Hop_TableDelete (Hop_Man_t *p, Hop_Obj_t *pObj)
int	Hop_TableCountEntries (Hop_Man_t *p)
void	Hop_TableProfile (Hop_Man_t *p)
unsigned *	Hop_ManConvertAigToTruth (Hop_Man_t *p, Hop_Obj_t *pRoot, int nVars, Vec_Int_t *vTruth, int fMsbFirst)
word	Hop_ManComputeTruth6 (Hop_Man_t *p, Hop_Obj_t *pObj, int nVars)
void	Hop_ManIncrementTravId (Hop_Man_t *p)
	DECLARATIONS ///. More...
void	Hop_ManCleanData (Hop_Man_t *p)
void	Hop_ObjCleanData_rec (Hop_Obj_t *pObj)
void	Hop_ObjCollectMulti (Hop_Obj_t *pFunc, Vec_Ptr_t *vSuper)
int	Hop_ObjIsMuxType (Hop_Obj_t *pObj)
int	Hop_ObjRecognizeExor (Hop_Obj_t *pObj, Hop_Obj_t **ppFan0, Hop_Obj_t **ppFan1)
Hop_Obj_t *	Hop_ObjRecognizeMux (Hop_Obj_t *pObj, Hop_Obj_t **ppObjT, Hop_Obj_t **ppObjE)
void	Hop_ObjPrintEqn (FILE *pFile, Hop_Obj_t *pObj, Vec_Vec_t *vLevels, int Level)
void	Hop_ObjPrintVerilog (FILE *pFile, Hop_Obj_t *pObj, Vec_Vec_t *vLevels, int Level)
void	Hop_ObjPrintVerbose (Hop_Obj_t *pObj, int fHaig)
void	Hop_ManPrintVerbose (Hop_Man_t *p, int fHaig)
void	Hop_ManDumpBlif (Hop_Man_t *p, char *pFileName)

Macro Definition Documentation

#define Hop_ManForEachNode	(		p,
			pObj,
			i
	)

Value:

for ( i = 0; i < p->nTableSize; i++ )                                       \
        if ( ((pObj) = p->pTable[i]) == NULL ) {} else

Definition at line 265 of file hop.h.

#define Hop_ManForEachPi	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Hop_Obj_t *, p->vPis, pObj, i )

ITERATORS ///.

Definition at line 259 of file hop.h.

#define Hop_ManForEachPo	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Hop_Obj_t *, p->vPos, pObj, i )

Definition at line 262 of file hop.h.

Typedef Documentation

typedef int Hop_Edge_t

Definition at line 51 of file hop.h.

typedef typedefABC_NAMESPACE_HEADER_START struct Hop_Man_t_ Hop_Man_t

INCLUDES ///.

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

FileName [hop.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Minimalistic And-Inverter Graph package.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 11, 2006.]

Revision [

Id:

hop.h,v 1.00 2006/05/11 00:00:00 alanmi Exp

]PARAMETERS ///BASIC TYPES ///

Definition at line 49 of file hop.h.

typedef struct Hop_Obj_t_ Hop_Obj_t

Definition at line 50 of file hop.h.

Enumeration Type Documentation

enum Hop_Type_t

Enumerator
AIG_NONE
AIG_CONST1
AIG_PI
AIG_PO
AIG_AND
AIG_EXOR
AIG_VOID

Definition at line 54 of file hop.h.

             { 
    AIG_NONE,                        // 0: non-existent object
    AIG_CONST1,                      // 1: constant 1 
    AIG_PI,                          // 2: primary input
    AIG_PO,                          // 3: primary output
    AIG_AND,                         // 4: AND node
    AIG_EXOR,                        // 5: EXOR node
    AIG_VOID                         // 6: unused object
} Hop_Type_t;

Function Documentation

Hop_Obj_t* Hop_And	(	Hop_Man_t *	p,
		Hop_Obj_t *	p0,
		Hop_Obj_t *	p1
	)

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

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 104 of file hopOper.c.

{
    Hop_Obj_t * pGhost, * pResult;
//    Hop_Obj_t * pFan0, * pFan1;
    // check trivial cases
    if ( p0 == p1 )
        return p0;
    if ( p0 == Hop_Not(p1) )
        return Hop_Not(p->pConst1);
    if ( Hop_Regular(p0) == p->pConst1 )
        return p0 == p->pConst1 ? p1 : Hop_Not(p->pConst1);
    if ( Hop_Regular(p1) == p->pConst1 )
        return p1 == p->pConst1 ? p0 : Hop_Not(p->pConst1);
    // check if it can be an EXOR gate
//    if ( Hop_ObjIsExorType( p0, p1, &pFan0, &pFan1 ) )
//        return Hop_Exor( p, pFan0, pFan1 );
    // check the table
    pGhost = Hop_ObjCreateGhost( p, p0, p1, AIG_AND );
    if ( (pResult = Hop_TableLookup( p, pGhost )) )
        return pResult;
    return Hop_ObjCreate( p, pGhost );
}

static int Hop_Base10Log ( unsigned  n )

inlinestatic

Definition at line 124 of file hop.h.

{ int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }

static int Hop_Base2Log ( unsigned  n )

inlinestatic

Definition at line 123 of file hop.h.

{ int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }

static int Hop_BitWordNum ( int  nBits )

inlinestatic

Definition at line 118 of file hop.h.

{ return (nBits>>5) + ((nBits&31) > 0);           }

Hop_Obj_t* Hop_Complement	(	Hop_Man_t *	p,
		Hop_Obj_t *	pRoot,
		int	iVar
	)

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

Synopsis [Complements the AIG (pRoot) with the function (pFunc) using PI var (iVar).]

Description []

SideEffects []

SeeAlso []

Definition at line 469 of file hopDfs.c.

{
    // quit if the PI variable is not defined
    if ( iVar >= Hop_ManPiNum(p) )
    {
        printf( "Hop_Complement(): The PI variable %d is not defined.\n", iVar );
        return NULL;
    }
    // recursively perform composition
    Hop_Complement_rec( p, Hop_Regular(pRoot), Hop_ManPi(p, iVar) );
    // clear the markings
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    return Hop_NotCond( (Hop_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );
}

Hop_Obj_t* Hop_Compose	(	Hop_Man_t *	p,
		Hop_Obj_t *	pRoot,
		Hop_Obj_t *	pFunc,
		int	iVar
	)

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

Synopsis [Composes the AIG (pRoot) with the function (pFunc) using PI var (iVar).]

Description []

SideEffects []

SeeAlso []

Definition at line 415 of file hopDfs.c.

{
    // quit if the PI variable is not defined
    if ( iVar >= Hop_ManPiNum(p) )
    {
        printf( "Hop_Compose(): The PI variable %d is not defined.\n", iVar );
        return NULL;
    }
    // recursively perform composition
    Hop_Compose_rec( p, Hop_Regular(pRoot), pFunc, Hop_ManPi(p, iVar) );
    // clear the markings
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    return Hop_NotCond( (Hop_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );
}

void Hop_ConeUnmark_rec

(

Hop_Obj_t *

pObj

)

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

Synopsis [Counts the number of AIG nodes rooted at this cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 257 of file hopDfs.c.

{
    assert( !Hop_IsComplement(pObj) );
    if ( !Hop_ObjIsNode(pObj) || !Hop_ObjIsMarkA(pObj) )
        return;
    Hop_ConeUnmark_rec( Hop_ObjFanin0(pObj) ); 
    Hop_ConeUnmark_rec( Hop_ObjFanin1(pObj) );
    assert( Hop_ObjIsMarkA(pObj) ); // loop detection
    Hop_ObjClearMarkA( pObj );
}

Hop_Obj_t* Hop_CreateAnd	(	Hop_Man_t *	p,
		int	nVars
	)

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

Synopsis [Creates AND function with nVars inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 320 of file hopOper.c.

{
    Hop_Obj_t * pFunc;
    int i;
    pFunc = Hop_ManConst1( p );
    for ( i = 0; i < nVars; i++ )
        pFunc = Hop_And( p, pFunc, Hop_IthVar(p, i) );
    return pFunc;
}

Hop_Obj_t* Hop_CreateExor	(	Hop_Man_t *	p,
		int	nVars
	)

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

Synopsis [Creates AND function with nVars inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 362 of file hopOper.c.

{
    Hop_Obj_t * pFunc;
    int i;
    pFunc = Hop_ManConst0( p );
    for ( i = 0; i < nVars; i++ )
        pFunc = Hop_Exor( p, pFunc, Hop_IthVar(p, i) );
    return pFunc;
}

Hop_Obj_t* Hop_CreateOr	(	Hop_Man_t *	p,
		int	nVars
	)

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

Synopsis [Creates AND function with nVars inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 341 of file hopOper.c.

{
    Hop_Obj_t * pFunc;
    int i;
    pFunc = Hop_ManConst0( p );
    for ( i = 0; i < nVars; i++ )
        pFunc = Hop_Or( p, pFunc, Hop_IthVar(p, i) );
    return pFunc;
}

int Hop_DagSize

(

Hop_Obj_t *

pObj

)

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

Synopsis [Counts the number of AIG nodes rooted at this cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 279 of file hopDfs.c.

{
    int Counter;
    Counter = Hop_ConeCountAndMark_rec( Hop_Regular(pObj) );
    Hop_ConeUnmark_rec( Hop_Regular(pObj) );
    return Counter;
}

static Hop_Edge_t Hop_EdgeCreate ( int  Id, int  fCompl  )

inlinestatic

Definition at line 138 of file hop.h.

{ return (Id << 1) | fCompl;             }

static int Hop_EdgeId ( Hop_Edge_t  Edge )

inlinestatic

Definition at line 139 of file hop.h.

{ return Edge >> 1;                      }

static int Hop_EdgeIsComplement ( Hop_Edge_t  Edge )

inlinestatic

Definition at line 140 of file hop.h.

{ return Edge & 1;                       }

static Hop_Edge_t Hop_EdgeNot ( Hop_Edge_t  Edge )

inlinestatic

Definition at line 142 of file hop.h.

{ return Edge ^ 1;                       }

static Hop_Edge_t Hop_EdgeNotCond ( Hop_Edge_t  Edge, int  fCond  )

inlinestatic

Definition at line 143 of file hop.h.

{ return Edge ^ fCond;                   }

static Hop_Edge_t Hop_EdgeRegular ( Hop_Edge_t  Edge )

inlinestatic

Definition at line 141 of file hop.h.

{ return (Edge >> 1) << 1;               }

Hop_Obj_t* Hop_Exor	(	Hop_Man_t *	p,
		Hop_Obj_t *	p0,
		Hop_Obj_t *	p1
	)

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

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 138 of file hopOper.c.

{
/*
    Hop_Obj_t * pGhost, * pResult;
    // check trivial cases
    if ( p0 == p1 )
        return Hop_Not(p->pConst1);
    if ( p0 == Hop_Not(p1) )
        return p->pConst1;
    if ( Hop_Regular(p0) == p->pConst1 )
        return Hop_NotCond( p1, p0 == p->pConst1 );
    if ( Hop_Regular(p1) == p->pConst1 )
        return Hop_NotCond( p0, p1 == p->pConst1 );
    // check the table
    pGhost = Hop_ObjCreateGhost( p, p0, p1, AIG_EXOR );
    if ( pResult = Hop_TableLookup( p, pGhost ) )
        return pResult;
    return Hop_ObjCreate( p, pGhost );
*/
    return Hop_Or( p, Hop_And(p, p0, Hop_Not(p1)), Hop_And(p, Hop_Not(p0), p1) );
}

static int Hop_InfoHasBit ( unsigned *  p, int  i  )

inlinestatic

Definition at line 120 of file hop.h.

{ return (p[(i)>>5] & (1<<((i) & 31))) > 0;       }

static void Hop_InfoSetBit ( unsigned *  p, int  i  )

inlinestatic

Definition at line 121 of file hop.h.

{ p[(i)>>5] |= (1<<((i) & 31));                   }

static void Hop_InfoXorBit ( unsigned *  p, int  i  )

inlinestatic

Definition at line 122 of file hop.h.

{ p[(i)>>5] ^= (1<<((i) & 31));                   }

static int Hop_IsComplement ( Hop_Obj_t *  p )

inlinestatic

Definition at line 129 of file hop.h.

{ return (int)((ABC_PTRUINT_T)(p) & 01);          }

Hop_Obj_t* Hop_IthVar	(	Hop_Man_t *	p,
		int	i
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Returns i-th elementary variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 63 of file hopOper.c.

{
    int v;
    for ( v = Hop_ManPiNum(p); v <= i; v++ )
        Hop_ObjCreatePi( p );
    assert( i < Vec_PtrSize(p->vPis) );
    return Hop_ManPi( p, i );
}

Hop_Obj_t* Hop_Maj	(	Hop_Man_t *	p,
		Hop_Obj_t *	pA,
		Hop_Obj_t *	pB,
		Hop_Obj_t *	pC
	)

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

Synopsis [Implements ITE operation.]

Description []

SideEffects []

SeeAlso []

Definition at line 242 of file hopOper.c.

{
    return Hop_Or( p, Hop_Or(p, Hop_And(p, pA, pB), Hop_And(p, pA, pC)), Hop_And(p, pB, pC) );
}

void Hop_ManAddMemory

(

Hop_Man_t *

p

)

MACRO DEFINITIONS ///.

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

Synopsis [Allocates additional memory for the nodes.]

Description [Allocates IVY_PAGE_SIZE nodes. Aligns memory by 32 bytes. Records the pointer to the AIG manager in the -1 entry.]

SideEffects []

SeeAlso []

Definition at line 89 of file hopMem.c.

{
    char * pMemory;
    int i, nBytes;
    assert( sizeof(Hop_Obj_t) <= 64 );
    assert( p->pListFree == NULL );
//    assert( (Hop_ManObjNum(p) & IVY_PAGE_MASK) == 0 );
    // allocate new memory page
    nBytes = sizeof(Hop_Obj_t) * (1<<IVY_PAGE_SIZE) + 64;
    pMemory = ABC_ALLOC( char, nBytes );
    Vec_PtrPush( p->vChunks, pMemory );
    // align memory at the 32-byte boundary
    pMemory = pMemory + 64 - (((int)(ABC_PTRUINT_T)pMemory) & 63);
    // remember the manager in the first entry
    Vec_PtrPush( p->vPages, pMemory );
    // break the memory down into nodes
    p->pListFree = (Hop_Obj_t *)pMemory;
    for ( i = 1; i <= IVY_PAGE_MASK; i++ )
    {
        *((char **)pMemory) = pMemory + sizeof(Hop_Obj_t);
        pMemory += sizeof(Hop_Obj_t);
    }
    *((char **)pMemory) = NULL;
}

static int Hop_ManAndNum ( Hop_Man_t *  p )

inlinestatic

Definition at line 147 of file hop.h.

{ return p->nObjs[AIG_AND];                   }

Hop_Man_t* Hop_ManBalance	(	Hop_Man_t *	p,
		int	fUpdateLevel
	)

FUNCTION DECLARATIONS ///.

FUNCTION DECLARATIONS ///.

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

Synopsis [Performs algebraic balancing of the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 51 of file hopBalance.c.

{
    Hop_Man_t * pNew;
    Hop_Obj_t * pObj, * pObjNew;
    Vec_Vec_t * vStore;
    int i;
    // create the new manager 
    pNew = Hop_ManStart();
    pNew->fRefCount = 0;
    // map the PI nodes
    Hop_ManCleanData( p );
    Hop_ManConst1(p)->pData = Hop_ManConst1(pNew);
    Hop_ManForEachPi( p, pObj, i )
        pObj->pData = Hop_ObjCreatePi(pNew);
    // balance the AIG
    vStore = Vec_VecAlloc( 50 );
    Hop_ManForEachPo( p, pObj, i )
    {
        pObjNew = Hop_NodeBalance_rec( pNew, Hop_ObjFanin0(pObj), vStore, 0, fUpdateLevel );
        Hop_ObjCreatePo( pNew, Hop_NotCond( pObjNew, Hop_ObjFaninC0(pObj) ) );
    }
    Vec_VecFree( vStore );
    // remove dangling nodes
//    Hop_ManCreateRefs( pNew );
//    if ( i = Hop_ManCleanup( pNew ) )
//        printf( "Cleanup after balancing removed %d dangling nodes.\n", i );
    // check the resulting AIG
    if ( !Hop_ManCheck(pNew) )
        printf( "Hop_ManBalance(): The check has failed.\n" );
    return pNew;
}

int Hop_ManCheck

(

Hop_Man_t *

p

)

DECLARATIONS ///.

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

FileName [hopCheck.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Minimalistic And-Inverter Graph package.]

Synopsis [AIG checking procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 11, 2006.]

Revision [

Id:

hopCheck.c,v 1.00 2006/05/11 00:00:00 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Checks the consistency of the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file hopCheck.c.

{
    Hop_Obj_t * pObj, * pObj2;
    int i;
    // check primary inputs
    Hop_ManForEachPi( p, pObj, i )
    {
        if ( Hop_ObjFanin0(pObj) || Hop_ObjFanin1(pObj) )
        {
            printf( "Hop_ManCheck: The PI node \"%p\" has fanins.\n", pObj );
            return 0;
        }
    }
    // check primary outputs
    Hop_ManForEachPo( p, pObj, i )
    {
        if ( !Hop_ObjFanin0(pObj) )
        {
            printf( "Hop_ManCheck: The PO node \"%p\" has NULL fanin.\n", pObj );
            return 0;
        }
        if ( Hop_ObjFanin1(pObj) )
        {
            printf( "Hop_ManCheck: The PO node \"%p\" has second fanin.\n", pObj );
            return 0;
        }
    }
    // check internal nodes
    Hop_ManForEachNode( p, pObj, i )
    {
        if ( !Hop_ObjFanin0(pObj) || !Hop_ObjFanin1(pObj) )
        {
            printf( "Hop_ManCheck: The AIG has internal node \"%p\" with a NULL fanin.\n", pObj );
            return 0;
        }
        if ( Hop_ObjFanin0(pObj)->Id >= Hop_ObjFanin1(pObj)->Id )
        {
            printf( "Hop_ManCheck: The AIG has node \"%p\" with a wrong ordering of fanins.\n", pObj );
            return 0;
        }
        pObj2 = Hop_TableLookup( p, pObj );
        if ( pObj2 != pObj )
        {
            printf( "Hop_ManCheck: Node \"%p\" is not in the structural hashing table.\n", pObj );
            return 0;
        }
    }
    // count the total number of nodes
    if ( Hop_ManObjNum(p) != 1 + Hop_ManPiNum(p) + Hop_ManPoNum(p) + Hop_ManAndNum(p) + Hop_ManExorNum(p) )
    {
        printf( "Hop_ManCheck: The number of created nodes is wrong.\n" );
        return 0;
    }
    // count the number of nodes in the table
    if ( Hop_TableCountEntries(p) != Hop_ManAndNum(p) + Hop_ManExorNum(p) )
    {
        printf( "Hop_ManCheck: The number of nodes in the structural hashing table is wrong.\n" );
        return 0;
    }
//    if ( !Hop_ManIsAcyclic(p) )
//        return 0;
    return 1; 
}

void Hop_ManCleanData

(

Hop_Man_t *

p

)

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

Synopsis [Cleans the data pointers for the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 63 of file hopUtil.c.

{
    Hop_Obj_t * pObj;
    int i;
    p->nTravIds = 1;
    Hop_ManConst1(p)->pData = NULL;
    Hop_ManForEachPi( p, pObj, i )
        pObj->pData = NULL;
    Hop_ManForEachPo( p, pObj, i )
        pObj->pData = NULL;
    Hop_ManForEachNode( p, pObj, i )
        pObj->pData = NULL;
}

int Hop_ManCleanup

(

Hop_Man_t *

p

)

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

Synopsis [Returns the number of dangling nodes removed.]

Description []

SideEffects []

SeeAlso []

Definition at line 120 of file hopMan.c.

{
    Vec_Ptr_t * vObjs;
    Hop_Obj_t * pNode;
    int i, nNodesOld;
    assert( p->fRefCount );
    nNodesOld = Hop_ManNodeNum(p);
    // collect roots of dangling nodes
    vObjs = Vec_PtrAlloc( 100 );
    Hop_ManForEachNode( p, pNode, i )
        if ( Hop_ObjRefs(pNode) == 0 )
            Vec_PtrPush( vObjs, pNode );
    // recursively remove dangling nodes
    Vec_PtrForEachEntry( Hop_Obj_t *, vObjs, pNode, i )
        Hop_ObjDelete_rec( p, pNode );
    Vec_PtrFree( vObjs );
    return nNodesOld - Hop_ManNodeNum(p);
}

word Hop_ManComputeTruth6	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj,
		int	nVars
	)

Definition at line 256 of file hopTruth.c.

{
    word Truth;
    int i;
    if ( Hop_ObjIsConst1( Hop_Regular(pObj) ) )
        return Hop_IsComplement(pObj) ? 0 : ~(word)0;
    for ( i = 0; i < nVars; i++ )
        Hop_ManPi( p, i )->iData = i;
    Truth = Hop_ManComputeTruth6_rec( p, Hop_Regular(pObj) );
    return Hop_IsComplement(pObj) ? ~Truth : Truth;
}

static Hop_Obj_t* Hop_ManConst0 ( Hop_Man_t *  p )

inlinestatic

Definition at line 131 of file hop.h.

{ return Hop_Not(p->pConst1);                     }

static Hop_Obj_t* Hop_ManConst1 ( Hop_Man_t *  p )

inlinestatic

Definition at line 132 of file hop.h.

{ return p->pConst1;                              }

unsigned* Hop_ManConvertAigToTruth	(	Hop_Man_t *	p,
		Hop_Obj_t *	pRoot,
		int	nVars,
		Vec_Int_t *	vTruth,
		int	fMsbFirst
	)

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

Synopsis [Computes truth table of the node.]

Description [Assumes that the structural support is no more than 8 inputs. Uses array vTruth to store temporary truth tables. The returned pointer should be used immediately.]

SideEffects []

SeeAlso []

Definition at line 143 of file hopTruth.c.

{
    static unsigned uTruths[8][8] = { // elementary truth tables
        { 0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA },
        { 0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC },
        { 0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0 },
        { 0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00 },
        { 0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000 }, 
        { 0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF }, 
        { 0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF }, 
        { 0x00000000,0x00000000,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF } 
    };
    Hop_Obj_t * pObj;
    unsigned * pTruth, * pTruth2;
    int i, nWords, nNodes;
    Vec_Ptr_t * vTtElems;

    // if the number of variables is more than 8, allocate truth tables
    if ( nVars > 8 )
        vTtElems = Vec_PtrAllocTruthTables( nVars );
    else
        vTtElems = NULL;

    // clear the data fields and set marks
    nNodes = Hop_ManConvertAigToTruth_rec1( Hop_Regular(pRoot) );
    // prepare memory
    nWords = Hop_TruthWordNum( nVars );
    Vec_IntClear( vTruth );
    Vec_IntGrow( vTruth, nWords * (nNodes+1) );
    pTruth = Vec_IntFetch( vTruth, nWords );
    // check the case of a constant
    if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
    {
        assert( nNodes == 0 );
        if ( Hop_IsComplement(pRoot) )
            Hop_ManTruthClear( pTruth, nVars );
        else
            Hop_ManTruthFill( pTruth, nVars );
        return pTruth;
    }
    // set elementary truth tables at the leaves
    assert( nVars <= Hop_ManPiNum(p) );
//    assert( Hop_ManPiNum(p) <= 8 ); 
    if ( fMsbFirst )
    {
//        Hop_ManForEachPi( p, pObj, i )
        for ( i = 0; i < nVars; i++ )
        {
            pObj = Hop_ManPi( p, i );
            if ( vTtElems )
                pObj->pData = Vec_PtrEntry(vTtElems, nVars-1-i);
            else               
                pObj->pData = (void *)uTruths[nVars-1-i];
        }
    }
    else
    {
//        Hop_ManForEachPi( p, pObj, i )
        for ( i = 0; i < nVars; i++ )
        {
            pObj = Hop_ManPi( p, i );
            if ( vTtElems )
                pObj->pData = Vec_PtrEntry(vTtElems, i);
            else               
                pObj->pData = (void *)uTruths[i];
        }
    }
    // clear the marks and compute the truth table
    pTruth2 = Hop_ManConvertAigToTruth_rec2( Hop_Regular(pRoot), vTruth, nWords );
    // copy the result
    Hop_ManTruthCopy( pTruth, pTruth2, nVars );
    if ( Hop_IsComplement(pRoot) )
        Hop_ManTruthNot( pTruth, pTruth, nVars );
    if ( vTtElems )
        Vec_PtrFree( vTtElems );
    return pTruth;
}

int Hop_ManCountLevels

(

Hop_Man_t *

p

)

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

Synopsis [Computes the max number of levels in the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 116 of file hopDfs.c.

{
    Vec_Ptr_t * vNodes;
    Hop_Obj_t * pObj;
    int i, LevelsMax, Level0, Level1;
    // initialize the levels
    Hop_ManConst1(p)->pData = NULL;
    Hop_ManForEachPi( p, pObj, i )
        pObj->pData = NULL;
    // compute levels in a DFS order
    vNodes = Hop_ManDfs( p );
    Vec_PtrForEachEntry( Hop_Obj_t *, vNodes, pObj, i )
    {
        Level0 = (int)(ABC_PTRUINT_T)Hop_ObjFanin0(pObj)->pData;
        Level1 = (int)(ABC_PTRUINT_T)Hop_ObjFanin1(pObj)->pData;
        pObj->pData = (void *)(ABC_PTRUINT_T)(1 + Hop_ObjIsExor(pObj) + Abc_MaxInt(Level0, Level1));
    }
    Vec_PtrFree( vNodes );
    // get levels of the POs
    LevelsMax = 0;
    Hop_ManForEachPo( p, pObj, i )
        LevelsMax = Abc_MaxInt( LevelsMax, (int)(ABC_PTRUINT_T)Hop_ObjFanin0(pObj)->pData );
    return LevelsMax;
}

void Hop_ManCreateRefs

(

Hop_Man_t *

p

)

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

Synopsis [Creates correct reference counters at each node.]

Description []

SideEffects []

SeeAlso []

Definition at line 152 of file hopDfs.c.

{
    Hop_Obj_t * pObj;
    int i;
    if ( p->fRefCount )
        return;
    p->fRefCount = 1;
    // clear refs
    Hop_ObjClearRef( Hop_ManConst1(p) );
    Hop_ManForEachPi( p, pObj, i )
        Hop_ObjClearRef( pObj );
    Hop_ManForEachNode( p, pObj, i )
        Hop_ObjClearRef( pObj );
    Hop_ManForEachPo( p, pObj, i )
        Hop_ObjClearRef( pObj );
    // set refs
    Hop_ManForEachNode( p, pObj, i )
    {
        Hop_ObjRef( Hop_ObjFanin0(pObj) );
        Hop_ObjRef( Hop_ObjFanin1(pObj) );
    }
    Hop_ManForEachPo( p, pObj, i )
        Hop_ObjRef( Hop_ObjFanin0(pObj) );
}

Vec_Ptr_t* Hop_ManDfs

(

Hop_Man_t *

p

)

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

Synopsis [Collects internal nodes in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 68 of file hopDfs.c.

{
    Vec_Ptr_t * vNodes;
    Hop_Obj_t * pObj;
    int i;
    vNodes = Vec_PtrAlloc( Hop_ManNodeNum(p) );
    Hop_ManForEachNode( p, pObj, i )
        Hop_ManDfs_rec( pObj, vNodes );
    Hop_ManForEachNode( p, pObj, i )
        Hop_ObjClearMarkA(pObj);
    return vNodes;
}

Vec_Ptr_t* Hop_ManDfsNode	(	Hop_Man_t *	p,
		Hop_Obj_t *	pNode
	)

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

Synopsis [Collects internal nodes in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 92 of file hopDfs.c.

{
    Vec_Ptr_t * vNodes;
    Hop_Obj_t * pObj;
    int i;
    assert( !Hop_IsComplement(pNode) );
    vNodes = Vec_PtrAlloc( 16 );
    Hop_ManDfs_rec( pNode, vNodes );
    Vec_PtrForEachEntry( Hop_Obj_t *, vNodes, pObj, i )
        Hop_ObjClearMarkA(pObj);
    return vNodes;
}

void Hop_ManDumpBlif	(	Hop_Man_t *	p,
		char *	pFileName
	)

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

Synopsis [Writes the AIG into the BLIF file.]

Description []

SideEffects []

SeeAlso []

Definition at line 509 of file hopUtil.c.

{
    FILE * pFile;
    Vec_Ptr_t * vNodes;
    Hop_Obj_t * pObj, * pConst1 = NULL;
    int i, nDigits, Counter = 0;
    if ( Hop_ManPoNum(p) == 0 )
    {
        printf( "Hop_ManDumpBlif(): AIG manager does not have POs.\n" );
        return;
    }
    // collect nodes in the DFS order
    vNodes = Hop_ManDfs( p );
    // assign IDs to objects
    Hop_ManConst1(p)->pData = (void *)(ABC_PTRUINT_T)Counter++;
    Hop_ManForEachPi( p, pObj, i )
        pObj->pData = (void *)(ABC_PTRUINT_T)Counter++;
    Hop_ManForEachPo( p, pObj, i )
        pObj->pData = (void *)(ABC_PTRUINT_T)Counter++;
    Vec_PtrForEachEntry( Hop_Obj_t *, vNodes, pObj, i )
        pObj->pData = (void *)(ABC_PTRUINT_T)Counter++;
    nDigits = Hop_Base10Log( Counter );
    // write the file
    pFile = fopen( pFileName, "w" );
    fprintf( pFile, "# BLIF file written by procedure Hop_ManDumpBlif() in ABC\n" );
    fprintf( pFile, "# http://www.eecs.berkeley.edu/~alanmi/abc/\n" );
    fprintf( pFile, ".model test\n" );
    // write PIs
    fprintf( pFile, ".inputs" );
    Hop_ManForEachPi( p, pObj, i )
        fprintf( pFile, " n%0*d", nDigits, (int)(ABC_PTRUINT_T)pObj->pData );
    fprintf( pFile, "\n" );
    // write POs
    fprintf( pFile, ".outputs" );
    Hop_ManForEachPo( p, pObj, i )
        fprintf( pFile, " n%0*d", nDigits, (int)(ABC_PTRUINT_T)pObj->pData );
    fprintf( pFile, "\n" );
    // write nodes
    Vec_PtrForEachEntry( Hop_Obj_t *, vNodes, pObj, i )
    {
        fprintf( pFile, ".names n%0*d n%0*d n%0*d\n", 
            nDigits, (int)(ABC_PTRUINT_T)Hop_ObjFanin0(pObj)->pData, 
            nDigits, (int)(ABC_PTRUINT_T)Hop_ObjFanin1(pObj)->pData, 
            nDigits, (int)(ABC_PTRUINT_T)pObj->pData );
        fprintf( pFile, "%d%d 1\n", !Hop_ObjFaninC0(pObj), !Hop_ObjFaninC1(pObj) );
    }
    // write POs
    Hop_ManForEachPo( p, pObj, i )
    {
        fprintf( pFile, ".names n%0*d n%0*d\n", 
            nDigits, (int)(ABC_PTRUINT_T)Hop_ObjFanin0(pObj)->pData, 
            nDigits, (int)(ABC_PTRUINT_T)pObj->pData );
        fprintf( pFile, "%d 1\n", !Hop_ObjFaninC0(pObj) );
        if ( Hop_ObjIsConst1(Hop_ObjFanin0(pObj)) )
            pConst1 = Hop_ManConst1(p);
    }
    if ( pConst1 )
        fprintf( pFile, ".names n%0*d\n 1\n", nDigits, (int)(ABC_PTRUINT_T)pConst1->pData );
    fprintf( pFile, ".end\n\n" );
    fclose( pFile );
    Vec_PtrFree( vNodes );
}

Hop_Man_t* Hop_ManDup

(

Hop_Man_t *

p

)

static int Hop_ManExorNum ( Hop_Man_t *  p )

inlinestatic

Definition at line 148 of file hop.h.

{ return p->nObjs[AIG_EXOR];                  }

static Hop_Obj_t* Hop_ManFetchMemory ( Hop_Man_t *  p )

inlinestatic

Definition at line 230 of file hop.h.

{ 
    Hop_Obj_t * pTemp;
    if ( p->pListFree == NULL )
        Hop_ManAddMemory( p );
    pTemp = p->pListFree;
    p->pListFree = *((Hop_Obj_t **)pTemp);
    memset( pTemp, 0, sizeof(Hop_Obj_t) ); 
    if ( p->vObjs )
    {
        assert( p->nCreated == Vec_PtrSize(p->vObjs) );
        Vec_PtrPush( p->vObjs, pTemp );
    }
    pTemp->Id = p->nCreated++;
    return pTemp;
}

static int Hop_ManGetCost ( Hop_Man_t *  p )

inlinestatic

Definition at line 150 of file hop.h.

{ return p->nObjs[AIG_AND]+3*p->nObjs[AIG_EXOR]; }

static Hop_Obj_t* Hop_ManGhost ( Hop_Man_t *  p )

inlinestatic

Definition at line 133 of file hop.h.

{ return &p->Ghost;                               }

void Hop_ManIncrementTravId

(

Hop_Man_t *

p

)

DECLARATIONS ///.

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

FileName [hopUtil.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [And-Inverter Graph package.]

Synopsis [Various procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 11, 2006.]

Revision [

Id:

hopUtil.c,v 1.00 2006/05/11 00:00:00 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Increments the current traversal ID of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file hopUtil.c.

{
    if ( p->nTravIds >= (1<<30)-1 )
        Hop_ManCleanData( p );
    p->nTravIds++;
}

static int Hop_ManNodeNum ( Hop_Man_t *  p )

inlinestatic

Definition at line 149 of file hop.h.

{ return p->nObjs[AIG_AND]+p->nObjs[AIG_EXOR];}

static Hop_Obj_t* Hop_ManObj ( Hop_Man_t *  p, int  i  )

inlinestatic

Definition at line 136 of file hop.h.

{ return p->vObjs ? (Hop_Obj_t *)Vec_PtrEntry(p->vObjs, i) : NULL;  }

static int Hop_ManObjNum ( Hop_Man_t *  p )

inlinestatic

Definition at line 151 of file hop.h.

{ return p->nCreated - p->nDeleted;           }

static Hop_Obj_t* Hop_ManPi ( Hop_Man_t *  p, int  i  )

inlinestatic

Definition at line 134 of file hop.h.

{ return (Hop_Obj_t *)Vec_PtrEntry(p->vPis, i);   }

static int Hop_ManPiNum ( Hop_Man_t *  p )

inlinestatic

Definition at line 145 of file hop.h.

{ return p->nObjs[AIG_PI];                    }

static Hop_Obj_t* Hop_ManPo ( Hop_Man_t *  p, int  i  )

inlinestatic

Definition at line 135 of file hop.h.

{ return (Hop_Obj_t *)Vec_PtrEntry(p->vPos, i);   }

static int Hop_ManPoNum ( Hop_Man_t *  p )

inlinestatic

Definition at line 146 of file hop.h.

{ return p->nObjs[AIG_PO];                    }

void Hop_ManPrintStats

(

Hop_Man_t *

p

)

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

Synopsis [Stops the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 150 of file hopMan.c.

{
    printf( "PI/PO = %d/%d. ", Hop_ManPiNum(p), Hop_ManPoNum(p) );
    printf( "A = %7d. ",       Hop_ManAndNum(p) );
    printf( "X = %5d. ",       Hop_ManExorNum(p) );
    printf( "Cre = %7d. ",     p->nCreated );
    printf( "Del = %7d. ",     p->nDeleted );
    printf( "Lev = %3d. ",     Hop_ManCountLevels(p) );
    printf( "\n" );
}

void Hop_ManPrintVerbose	(	Hop_Man_t *	p,
		int	fHaig
	)

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

Synopsis [Prints node in HAIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 482 of file hopUtil.c.

{
    Vec_Ptr_t * vNodes;
    Hop_Obj_t * pObj;
    int i;
    printf( "PIs: " );
    Hop_ManForEachPi( p, pObj, i )
        printf( " %p", pObj );
    printf( "\n" );
    vNodes = Hop_ManDfs( p );
    Vec_PtrForEachEntry( Hop_Obj_t *, vNodes, pObj, i )
        Hop_ObjPrintVerbose( pObj, fHaig ), printf( "\n" );
    printf( "\n" );
    Vec_PtrFree( vNodes );
}

static void Hop_ManRecycleMemory ( Hop_Man_t *  p, Hop_Obj_t *  pEntry  )

inlinestatic

Definition at line 246 of file hop.h.

{
    pEntry->Type = AIG_NONE; // distinquishes dead node from live node
    *((Hop_Obj_t **)pEntry) = p->pListFree;
    p->pListFree = pEntry;
}

Hop_Man_t* Hop_ManStart

(

)

DECLARATIONS ///.

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

FileName [hopMan.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Minimalistic And-Inverter Graph package.]

Synopsis [AIG manager.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 11, 2006.]

Revision [

Id:

hopMan.c,v 1.00 2006/05/11 00:00:00 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Starts the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file hopMan.c.

{
    Hop_Man_t * p;
    // start the manager
    p = ABC_ALLOC( Hop_Man_t, 1 );
    memset( p, 0, sizeof(Hop_Man_t) );
    // perform initializations
    p->nTravIds = 1;
    p->fRefCount = 1;
    p->fCatchExor = 0;
    // allocate arrays for nodes
    p->vPis = Vec_PtrAlloc( 100 );
    p->vPos = Vec_PtrAlloc( 100 );
    // prepare the internal memory manager
    Hop_ManStartMemory( p );
    // create the constant node
    p->pConst1 = Hop_ManFetchMemory( p );
    p->pConst1->Type = AIG_CONST1;
    p->pConst1->fPhase = 1;
    p->nCreated = 1;
    // start the table
//    p->nTableSize = 107;
    p->nTableSize = 10007;
    p->pTable = ABC_ALLOC( Hop_Obj_t *, p->nTableSize );
    memset( p->pTable, 0, sizeof(Hop_Obj_t *) * p->nTableSize );
    return p;
}

void Hop_ManStartMemory

(

Hop_Man_t *

p

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Starts the internal memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file hopMem.c.

{
    p->vChunks = Vec_PtrAlloc( 128 );
    p->vPages = Vec_PtrAlloc( 128 );
}

void Hop_ManStop

(

Hop_Man_t *

p

)

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

Synopsis [Stops the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 84 of file hopMan.c.

{
    Hop_Obj_t * pObj;
    int i;
    // make sure the nodes have clean marks
    pObj = Hop_ManConst1(p);
    assert( !pObj->fMarkA && !pObj->fMarkB );
    Hop_ManForEachPi( p, pObj, i )
        assert( !pObj->fMarkA && !pObj->fMarkB );
    Hop_ManForEachPo( p, pObj, i )
        assert( !pObj->fMarkA && !pObj->fMarkB );
    Hop_ManForEachNode( p, pObj, i )
        assert( !pObj->fMarkA && !pObj->fMarkB );
    // print time
    if ( p->time1 ) { ABC_PRT( "time1", p->time1 ); }
    if ( p->time2 ) { ABC_PRT( "time2", p->time2 ); }
//    Hop_TableProfile( p );
    if ( p->vChunks )  Hop_ManStopMemory( p );
    if ( p->vPis )     Vec_PtrFree( p->vPis );
    if ( p->vPos )     Vec_PtrFree( p->vPos );
    if ( p->vObjs )    Vec_PtrFree( p->vObjs );
    ABC_FREE( p->pTable );
    ABC_FREE( p );
}

void Hop_ManStopMemory

(

Hop_Man_t *

p

)

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

Synopsis [Stops the internal memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 66 of file hopMem.c.

{
    void * pMemory;
    int i;
    Vec_PtrForEachEntry( void *, p->vChunks, pMemory, i )
        ABC_FREE( pMemory );
    Vec_PtrFree( p->vChunks );
    Vec_PtrFree( p->vPages );
    p->pListFree = NULL;
}

Hop_Obj_t* Hop_Miter	(	Hop_Man_t *	p,
		Vec_Ptr_t *	vPairs
	)

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

Synopsis [Implements the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 297 of file hopOper.c.

{
    int i;
    assert( vPairs->nSize > 0 );
    assert( vPairs->nSize % 2 == 0 );
    // go through the cubes of the node's SOP
    for ( i = 0; i < vPairs->nSize; i += 2 )
        vPairs->pArray[i/2] = Hop_Not( Hop_Exor( p, (Hop_Obj_t *)vPairs->pArray[i], (Hop_Obj_t *)vPairs->pArray[i+1] ) );
    vPairs->nSize = vPairs->nSize/2;
    return Hop_Not( Hop_Multi_rec( p, (Hop_Obj_t **)vPairs->pArray, vPairs->nSize, AIG_AND ) );
}

Hop_Obj_t* Hop_Mux	(	Hop_Man_t *	p,
		Hop_Obj_t *	pC,
		Hop_Obj_t *	p1,
		Hop_Obj_t *	p0
	)

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

Synopsis [Implements ITE operation.]

Description []

SideEffects []

SeeAlso []

Definition at line 187 of file hopOper.c.

{
/*    
    Hop_Obj_t * pTempA1, * pTempA2, * pTempB1, * pTempB2, * pTemp;
    int Count0, Count1;
    // consider trivial cases
    if ( p0 == Hop_Not(p1) )
        return Hop_Exor( p, pC, p0 );
    // other cases can be added
    // implement the first MUX (F = C * x1 + C' * x0)

    // check for constants here!!!

    pTempA1 = Hop_TableLookup( p, Hop_ObjCreateGhost(p, pC,          p1, AIG_AND) );
    pTempA2 = Hop_TableLookup( p, Hop_ObjCreateGhost(p, Hop_Not(pC), p0, AIG_AND) );
    if ( pTempA1 && pTempA2 )
    {
        pTemp = Hop_TableLookup( p, Hop_ObjCreateGhost(p, Hop_Not(pTempA1), Hop_Not(pTempA2), AIG_AND) );
        if ( pTemp ) return Hop_Not(pTemp);
    }
    Count0 = (pTempA1 != NULL) + (pTempA2 != NULL);
    // implement the second MUX (F' = C * x1' + C' * x0')
    pTempB1 = Hop_TableLookup( p, Hop_ObjCreateGhost(p, pC,          Hop_Not(p1), AIG_AND) );
    pTempB2 = Hop_TableLookup( p, Hop_ObjCreateGhost(p, Hop_Not(pC), Hop_Not(p0), AIG_AND) );
    if ( pTempB1 && pTempB2 )
    {
        pTemp = Hop_TableLookup( p, Hop_ObjCreateGhost(p, Hop_Not(pTempB1), Hop_Not(pTempB2), AIG_AND) );
        if ( pTemp ) return pTemp;
    }
    Count1 = (pTempB1 != NULL) + (pTempB2 != NULL);
    // compare and decide which one to implement
    if ( Count0 >= Count1 )
    {
        pTempA1 = pTempA1? pTempA1 : Hop_And(p, pC,          p1);
        pTempA2 = pTempA2? pTempA2 : Hop_And(p, Hop_Not(pC), p0);
        return Hop_Or( p, pTempA1, pTempA2 );
    }
    pTempB1 = pTempB1? pTempB1 : Hop_And(p, pC,          Hop_Not(p1));
    pTempB2 = pTempB2? pTempB2 : Hop_And(p, Hop_Not(pC), Hop_Not(p0));
    return Hop_Not( Hop_Or( p, pTempB1, pTempB2 ) );
*/
    return Hop_Or( p, Hop_And(p, pC, p1), Hop_And(p, Hop_Not(pC), p0) );
}

Hop_Obj_t* Hop_NodeBalanceBuildSuper	(	Hop_Man_t *	p,
		Vec_Ptr_t *	vSuper,
		Hop_Type_t	Type,
		int	fUpdateLevel
	)

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

Synopsis [Builds implication supergate.]

Description []

SideEffects []

SeeAlso []

Definition at line 243 of file hopBalance.c.

{
    Hop_Obj_t * pObj1, * pObj2;
    int LeftBound;
    assert( vSuper->nSize > 1 );
    // sort the new nodes by level in the decreasing order
    Vec_PtrSort( vSuper, (int (*)(void))Hop_NodeCompareLevelsDecrease );
    // balance the nodes
    while ( vSuper->nSize > 1 )
    {
        // find the left bound on the node to be paired
        LeftBound = (!fUpdateLevel)? 0 : Hop_NodeBalanceFindLeft( vSuper );
        // find the node that can be shared (if no such node, randomize choice)
        Hop_NodeBalancePermute( p, vSuper, LeftBound, Type == AIG_EXOR );
        // pull out the last two nodes
        pObj1 = (Hop_Obj_t *)Vec_PtrPop(vSuper);
        pObj2 = (Hop_Obj_t *)Vec_PtrPop(vSuper);
        Hop_NodeBalancePushUniqueOrderByLevel( vSuper, Hop_Oper(p, pObj1, pObj2, Type) );
    }
    return (Hop_Obj_t *)Vec_PtrEntry(vSuper, 0);
}

static Hop_Obj_t* Hop_Not ( Hop_Obj_t *  p )

inlinestatic

Definition at line 127 of file hop.h.

{ return (Hop_Obj_t *)((ABC_PTRUINT_T)(p) ^  01); }

static Hop_Obj_t* Hop_NotCond ( Hop_Obj_t *  p, int  c  )

inlinestatic

Definition at line 128 of file hop.h.

{ return (Hop_Obj_t *)((ABC_PTRUINT_T)(p) ^ (c)); }

static Hop_Obj_t* Hop_ObjChild0 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 184 of file hop.h.

{ return pObj->pFanin0;                          }

static Hop_Obj_t* Hop_ObjChild0Copy ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 186 of file hop.h.

{ assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin0(pObj)? Hop_NotCond((Hop_Obj_t *)Hop_ObjFanin0(pObj)->pData, Hop_ObjFaninC0(pObj)) : NULL;  }

static int Hop_ObjChild0CopyI ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 188 of file hop.h.

{ assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin0(pObj)? Abc_LitNotCond(Hop_ObjFanin0(pObj)->iData, Hop_ObjFaninC0(pObj)) : -1;              }

static Hop_Obj_t* Hop_ObjChild1 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 185 of file hop.h.

{ return pObj->pFanin1;                          }

static Hop_Obj_t* Hop_ObjChild1Copy ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 187 of file hop.h.

{ assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin1(pObj)? Hop_NotCond((Hop_Obj_t *)Hop_ObjFanin1(pObj)->pData, Hop_ObjFaninC1(pObj)) : NULL;  }

static int Hop_ObjChild1CopyI ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 189 of file hop.h.

{ assert( !Hop_IsComplement(pObj) ); return Hop_ObjFanin1(pObj)? Abc_LitNotCond(Hop_ObjFanin1(pObj)->iData, Hop_ObjFaninC1(pObj)) : -1;              }

static void Hop_ObjClean ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 193 of file hop.h.

{ memset( pObj, 0, sizeof(Hop_Obj_t) ); }

void Hop_ObjCleanData_rec

(

Hop_Obj_t *

pObj

)

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

Synopsis [Recursively cleans the data pointers in the cone of the node.]

Description [Applicable to small AIGs only because no caching is performed.]

SideEffects []

SeeAlso []

Definition at line 88 of file hopUtil.c.

{
    assert( !Hop_IsComplement(pObj) );
    assert( !Hop_ObjIsPo(pObj) );
    if ( Hop_ObjIsAnd(pObj) )
    {
        Hop_ObjCleanData_rec( Hop_ObjFanin0(pObj) );
        Hop_ObjCleanData_rec( Hop_ObjFanin1(pObj) );
    }
    pObj->pData = NULL;
}

static void Hop_ObjClearMarkA ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 166 of file hop.h.

{ pObj->fMarkA = 0;     }

static void Hop_ObjClearRef ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 179 of file hop.h.

{ pObj->nRefs = 0;                               }

void Hop_ObjCollectMulti	(	Hop_Obj_t *	pRoot,
		Vec_Ptr_t *	vSuper
	)

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

Synopsis [Detects multi-input gate rooted at this node.]

Description []

SideEffects []

SeeAlso []

Definition at line 133 of file hopUtil.c.

{
    assert( !Hop_IsComplement(pRoot) );
    Vec_PtrClear( vSuper );
    Hop_ObjCollectMulti_rec( pRoot, pRoot, vSuper );
}

void Hop_ObjConnect	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj,
		Hop_Obj_t *	pFan0,
		Hop_Obj_t *	pFan1
	)

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

Synopsis [Connect the object to the fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 125 of file hopObj.c.

{
    assert( !Hop_IsComplement(pObj) );
    assert( Hop_ObjIsNode(pObj) );
    // add the first fanin
    pObj->pFanin0 = pFan0;
    pObj->pFanin1 = pFan1;
    // increment references of the fanins and add their fanouts
    if ( p->fRefCount )
    {
        if ( pFan0 != NULL )
            Hop_ObjRef( Hop_ObjFanin0(pObj) );
        if ( pFan1 != NULL )
            Hop_ObjRef( Hop_ObjFanin1(pObj) );
    }
    else
        pObj->nRefs = Hop_ObjLevelNew( pObj );
    // set the phase
    pObj->fPhase = Hop_ObjPhaseCompl(pFan0) & Hop_ObjPhaseCompl(pFan1);
    // add the node to the structural hash table
    Hop_TableInsert( p, pObj );
}

Hop_Obj_t* Hop_ObjCreate	(	Hop_Man_t *	p,
		Hop_Obj_t *	pGhost
	)

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

Synopsis [Create the new node assuming it does not exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 97 of file hopObj.c.

{
    Hop_Obj_t * pObj;
    assert( !Hop_IsComplement(pGhost) );
    assert( Hop_ObjIsNode(pGhost) );
    assert( pGhost == &p->Ghost );
    // get memory for the new object
    pObj = Hop_ManFetchMemory( p );
    pObj->Type = pGhost->Type;
    // add connections
    Hop_ObjConnect( p, pObj, pGhost->pFanin0, pGhost->pFanin1 );
    // update node counters of the manager
    p->nObjs[Hop_ObjType(pObj)]++;
    assert( pObj->pData == NULL );
    return pObj;
}

void Hop_ObjCreateChoice	(	Hop_Obj_t *	pOld,
		Hop_Obj_t *	pNew
	)

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

Synopsis [Sets an equivalence relation between the nodes.]

Description [Makes the representative of pNew point to the representaive of pOld.]

SideEffects []

SeeAlso []

Definition at line 260 of file hopObj.c.

{
    Hop_Obj_t * pOldRepr;
    Hop_Obj_t * pNewRepr;
    assert( pOld != NULL && pNew != NULL );
    pOldRepr = Hop_ObjRepr(pOld);
    pNewRepr = Hop_ObjRepr(pNew);
    if ( pNewRepr != pOldRepr )
        pNewRepr->pData = pOldRepr;
}

static Hop_Obj_t* Hop_ObjCreateGhost ( Hop_Man_t *  p, Hop_Obj_t *  p0, Hop_Obj_t *  p1, Hop_Type_t  Type  )

inlinestatic

Definition at line 208 of file hop.h.

{
    Hop_Obj_t * pGhost;
    assert( Type != AIG_AND || !Hop_ObjIsConst1(Hop_Regular(p0)) );
    assert( p1 == NULL || !Hop_ObjIsConst1(Hop_Regular(p1)) );
    assert( Type == AIG_PI || Hop_Regular(p0) != Hop_Regular(p1) );
    pGhost = Hop_ManGhost(p);
    pGhost->Type = Type;
    if ( Hop_Regular(p0)->Id < Hop_Regular(p1)->Id )
    {
        pGhost->pFanin0 = p0;
        pGhost->pFanin1 = p1;
    }
    else
    {
        pGhost->pFanin0 = p1;
        pGhost->pFanin1 = p0;
    }
    return pGhost;
}

Hop_Obj_t* Hop_ObjCreatePi

(

Hop_Man_t *

p

)

DECLARATIONS ///.

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

FileName [hopObj.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Minimalistic And-Inverter Graph package.]

Synopsis [Adding/removing objects.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 11, 2006.]

Revision [

Id:

hopObj.c,v 1.00 2006/05/11 00:00:00 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Creates primary input.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file hopObj.c.

{
    Hop_Obj_t * pObj;
    pObj = Hop_ManFetchMemory( p );
    pObj->Type = AIG_PI;
    pObj->PioNum = Vec_PtrSize( p->vPis );
    Vec_PtrPush( p->vPis, pObj );
    p->nObjs[AIG_PI]++;
    return pObj;
}

Hop_Obj_t* Hop_ObjCreatePo	(	Hop_Man_t *	p,
		Hop_Obj_t *	pDriver
	)

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

Synopsis [Creates primary output with the given driver.]

Description []

SideEffects []

SeeAlso []

Definition at line 67 of file hopObj.c.

{
    Hop_Obj_t * pObj;
    pObj = Hop_ManFetchMemory( p );
    pObj->Type = AIG_PO;
    Vec_PtrPush( p->vPos, pObj );
    // add connections
    pObj->pFanin0 = pDriver;
    if ( p->fRefCount )
        Hop_ObjRef( Hop_Regular(pDriver) );
    else
        pObj->nRefs = Hop_ObjLevel( Hop_Regular(pDriver) );
    // set the phase
    pObj->fPhase = Hop_ObjPhaseCompl(pDriver);
    // update node counters of the manager
    p->nObjs[AIG_PO]++;
    return pObj;
}

void Hop_ObjDelete	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj
	)

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

Synopsis [Deletes the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 186 of file hopObj.c.

{
    assert( !Hop_IsComplement(pObj) );
    assert( !Hop_ObjIsTerm(pObj) );
    assert( Hop_ObjRefs(pObj) == 0 );
    // update node counters of the manager
    p->nObjs[pObj->Type]--;
    p->nDeleted++;
    // remove connections
    Hop_ObjDisconnect( p, pObj );
    // remove PIs/POs from the arrays
    if ( Hop_ObjIsPi(pObj) )
        Vec_PtrRemove( p->vPis, pObj );
    // free the node
    Hop_ManRecycleMemory( p, pObj );
}

void Hop_ObjDelete_rec	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj
	)

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

Synopsis [Deletes the MFFC of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 214 of file hopObj.c.

{
    Hop_Obj_t * pFanin0, * pFanin1;
    assert( !Hop_IsComplement(pObj) );
    if ( Hop_ObjIsConst1(pObj) || Hop_ObjIsPi(pObj) )
        return;
    assert( Hop_ObjIsNode(pObj) );
    pFanin0 = Hop_ObjFanin0(pObj);
    pFanin1 = Hop_ObjFanin1(pObj);
    Hop_ObjDelete( p, pObj );
    if ( pFanin0 && !Hop_ObjIsNone(pFanin0) && Hop_ObjRefs(pFanin0) == 0 )
        Hop_ObjDelete_rec( p, pFanin0 );
    if ( pFanin1 && !Hop_ObjIsNone(pFanin1) && Hop_ObjRefs(pFanin1) == 0 )
        Hop_ObjDelete_rec( p, pFanin1 );
}

static void Hop_ObjDeref ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 178 of file hop.h.

{ assert( pObj->nRefs > 0 ); pObj->nRefs--;      }

void Hop_ObjDisconnect	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj
	)

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

Synopsis [Connect the object to the fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 159 of file hopObj.c.

{
    assert( !Hop_IsComplement(pObj) );
    assert( Hop_ObjIsNode(pObj) );
    // remove connections
    if ( pObj->pFanin0 != NULL )
        Hop_ObjDeref(Hop_ObjFanin0(pObj));
    if ( pObj->pFanin1 != NULL )
        Hop_ObjDeref(Hop_ObjFanin1(pObj));
    // remove the node from the structural hash table
    Hop_TableDelete( p, pObj );
    // add the first fanin
    pObj->pFanin0 = NULL;
    pObj->pFanin1 = NULL;
}

static Hop_Obj_t* Hop_ObjFanin0 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 182 of file hop.h.

{ return Hop_Regular(pObj->pFanin0);             }

static Hop_Obj_t* Hop_ObjFanin1 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 183 of file hop.h.

{ return Hop_Regular(pObj->pFanin1);             }

static int Hop_ObjFaninC0 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 180 of file hop.h.

{ return Hop_IsComplement(pObj->pFanin0);        }

static int Hop_ObjFaninC1 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 181 of file hop.h.

{ return Hop_IsComplement(pObj->pFanin1);        }

static int Hop_ObjFanoutC ( Hop_Obj_t *  pObj, Hop_Obj_t *  pFanout  )

inlinestatic

Definition at line 200 of file hop.h.

{ 
    if ( Hop_ObjFanin0(pFanout) == pObj ) return Hop_ObjFaninC0(pObj); 
    if ( Hop_ObjFanin1(pFanout) == pObj ) return Hop_ObjFaninC1(pObj); 
    assert(0); return -1; 
}

int Hop_ObjFanoutCount	(	Hop_Obj_t *	pObj,
		Hop_Obj_t *	pPivot
	)

Definition at line 310 of file hopDfs.c.

{
    int Counter;
    assert( !Hop_IsComplement(pPivot) );
    Counter = Hop_ObjFanoutCount_rec( Hop_Regular(pObj), pPivot );
    Hop_ConeUnmark_rec( Hop_Regular(pObj) );
    return Counter;
}

static int Hop_ObjIsAnd ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 158 of file hop.h.

{ return pObj->Type == AIG_AND;    }

static int Hop_ObjIsConst1 ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 155 of file hop.h.

{ assert(!Hop_IsComplement(pObj)); return pObj->Type == AIG_CONST1; }

static int Hop_ObjIsExor ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 159 of file hop.h.

{ return pObj->Type == AIG_EXOR;   }

static int Hop_ObjIsHash ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 162 of file hop.h.

{ return pObj->Type == AIG_AND || pObj->Type == AIG_EXOR;   }

static int Hop_ObjIsMarkA ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 164 of file hop.h.

{ return pObj->fMarkA;  }

int Hop_ObjIsMuxType

(

Hop_Obj_t *

pNode

)

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

Synopsis [Returns 1 if the node is the root of MUX or EXOR/NEXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 151 of file hopUtil.c.

{
    Hop_Obj_t * pNode0, * pNode1;
    // check that the node is regular
    assert( !Hop_IsComplement(pNode) );
    // if the node is not AND, this is not MUX
    if ( !Hop_ObjIsAnd(pNode) )
        return 0;
    // if the children are not complemented, this is not MUX
    if ( !Hop_ObjFaninC0(pNode) || !Hop_ObjFaninC1(pNode) )
        return 0;
    // get children
    pNode0 = Hop_ObjFanin0(pNode);
    pNode1 = Hop_ObjFanin1(pNode);
    // if the children are not ANDs, this is not MUX
    if ( !Hop_ObjIsAnd(pNode0) || !Hop_ObjIsAnd(pNode1) )
        return 0;
    // otherwise the node is MUX iff it has a pair of equal grandchildren
    return (Hop_ObjFanin0(pNode0) == Hop_ObjFanin0(pNode1) && (Hop_ObjFaninC0(pNode0) ^ Hop_ObjFaninC0(pNode1))) || 
           (Hop_ObjFanin0(pNode0) == Hop_ObjFanin1(pNode1) && (Hop_ObjFaninC0(pNode0) ^ Hop_ObjFaninC1(pNode1))) ||
           (Hop_ObjFanin1(pNode0) == Hop_ObjFanin0(pNode1) && (Hop_ObjFaninC1(pNode0) ^ Hop_ObjFaninC0(pNode1))) ||
           (Hop_ObjFanin1(pNode0) == Hop_ObjFanin1(pNode1) && (Hop_ObjFaninC1(pNode0) ^ Hop_ObjFaninC1(pNode1)));
}

static int Hop_ObjIsNode ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 160 of file hop.h.

{ return pObj->Type == AIG_AND || pObj->Type == AIG_EXOR;   }

static int Hop_ObjIsNone ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 154 of file hop.h.

{ return pObj->Type == AIG_NONE;   }

static int Hop_ObjIsPi ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 156 of file hop.h.

{ return pObj->Type == AIG_PI;     }

static int Hop_ObjIsPo ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 157 of file hop.h.

{ return pObj->Type == AIG_PO;     }

static int Hop_ObjIsTerm ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 161 of file hop.h.

{ return pObj->Type == AIG_PI  || pObj->Type == AIG_PO || pObj->Type == AIG_CONST1; }

static int Hop_ObjIsTravIdCurrent ( Hop_Man_t *  p, Hop_Obj_t *  pObj  )

inlinestatic

Definition at line 171 of file hop.h.

{ return (int)((int)(ABC_PTRINT_T)pObj->pData == p->nTravIds);     }

static int Hop_ObjIsTravIdPrevious ( Hop_Man_t *  p, Hop_Obj_t *  pObj  )

inlinestatic

Definition at line 172 of file hop.h.

{ return (int)((int)(ABC_PTRINT_T)pObj->pData == p->nTravIds - 1); }

static int Hop_ObjLevel ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 190 of file hop.h.

{ return pObj->nRefs;                            }

static int Hop_ObjLevelNew ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 191 of file hop.h.

{ return 1 + Hop_ObjIsExor(pObj) + Abc_MaxInt(Hop_ObjFanin0(pObj)->nRefs, Hop_ObjFanin1(pObj)->nRefs);       }

static int Hop_ObjPhase ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 175 of file hop.h.

{ return pObj->fPhase;                           }

static int Hop_ObjPhaseCompl ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 192 of file hop.h.

{ return Hop_IsComplement(pObj)? !Hop_Regular(pObj)->fPhase : pObj->fPhase; }

void Hop_ObjPrintEqn	(	FILE *	pFile,
		Hop_Obj_t *	pObj,
		Vec_Vec_t *	vLevels,
		int	Level
	)

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

Synopsis [Prints Eqn formula for the AIG rooted at this node.]

Description [The formula is in terms of PIs, which should have their names assigned in pObj->pData fields.]

SideEffects []

SeeAlso []

Definition at line 322 of file hopUtil.c.

{
    Vec_Ptr_t * vSuper;
    Hop_Obj_t * pFanin;
    int fCompl, i;
    // store the complemented attribute
    fCompl = Hop_IsComplement(pObj);
    pObj = Hop_Regular(pObj);
    // constant case
    if ( Hop_ObjIsConst1(pObj) )
    {
        fprintf( pFile, "%d", !fCompl );
        return;
    }
    // PI case
    if ( Hop_ObjIsPi(pObj) )
    {
        fprintf( pFile, "%s%s", fCompl? "!" : "", (char*)pObj->pData );
        return;
    }
    // AND case
    Vec_VecExpand( vLevels, Level );
    vSuper = Vec_VecEntry(vLevels, Level);
    Hop_ObjCollectMulti( pObj, vSuper );
    fprintf( pFile, "%s", (Level==0? "" : "(") );
    Vec_PtrForEachEntry( Hop_Obj_t *, vSuper, pFanin, i )
    {
        Hop_ObjPrintEqn( pFile, Hop_NotCond(pFanin, fCompl), vLevels, Level+1 );
        if ( i < Vec_PtrSize(vSuper) - 1 )
            fprintf( pFile, " %s ", fCompl? "+" : "*" );
    }
    fprintf( pFile, "%s", (Level==0? "" : ")") );
    return;
}

void Hop_ObjPrintVerbose	(	Hop_Obj_t *	pObj,
		int	fHaig
	)

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

Synopsis [Prints node in HAIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 456 of file hopUtil.c.

{
    assert( !Hop_IsComplement(pObj) );
    printf( "Node %p : ", pObj );
    if ( Hop_ObjIsConst1(pObj) )
        printf( "constant 1" );
    else if ( Hop_ObjIsPi(pObj) )
        printf( "PI" );
    else
        printf( "AND( %p%s, %p%s )", 
            Hop_ObjFanin0(pObj), (Hop_ObjFaninC0(pObj)? "\'" : " "), 
            Hop_ObjFanin1(pObj), (Hop_ObjFaninC1(pObj)? "\'" : " ") );
    printf( " (refs = %3d)", Hop_ObjRefs(pObj) );
}

void Hop_ObjPrintVerilog	(	FILE *	pFile,
		Hop_Obj_t *	pObj,
		Vec_Vec_t *	vLevels,
		int	Level
	)

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

Synopsis [Prints Verilog formula for the AIG rooted at this node.]

Description [The formula is in terms of PIs, which should have their names assigned in pObj->pData fields.]

SideEffects []

SeeAlso []

Definition at line 369 of file hopUtil.c.

{
    Vec_Ptr_t * vSuper;
    Hop_Obj_t * pFanin, * pFanin0, * pFanin1, * pFaninC;
    int fCompl, i;
    // store the complemented attribute
    fCompl = Hop_IsComplement(pObj);
    pObj = Hop_Regular(pObj);
    // constant case
    if ( Hop_ObjIsConst1(pObj) )
    {
        fprintf( pFile, "1\'b%d", !fCompl );
        return;
    }
    // PI case
    if ( Hop_ObjIsPi(pObj) )
    {
        fprintf( pFile, "%s%s", fCompl? "~" : "", (char*)pObj->pData );
        return;
    }
    // EXOR case
    if ( Hop_ObjIsExor(pObj) )
    {
        Vec_VecExpand( vLevels, Level );
        vSuper = Vec_VecEntry( vLevels, Level );
        Hop_ObjCollectMulti( pObj, vSuper );
        fprintf( pFile, "%s", (Level==0? "" : "(") );
        Vec_PtrForEachEntry( Hop_Obj_t *, vSuper, pFanin, i )
        {
            Hop_ObjPrintVerilog( pFile, Hop_NotCond(pFanin, (fCompl && i==0)), vLevels, Level+1 );
            if ( i < Vec_PtrSize(vSuper) - 1 )
                fprintf( pFile, " ^ " );
        }
        fprintf( pFile, "%s", (Level==0? "" : ")") );
        return;
    }
    // MUX case
    if ( Hop_ObjIsMuxType(pObj) )
    {
        if ( Hop_ObjRecognizeExor( pObj, &pFanin0, &pFanin1 ) )
        {
            fprintf( pFile, "%s", (Level==0? "" : "(") );
            Hop_ObjPrintVerilog( pFile, Hop_NotCond(pFanin0, fCompl), vLevels, Level+1 );
            fprintf( pFile, " ^ " );
            Hop_ObjPrintVerilog( pFile, pFanin1, vLevels, Level+1 );
            fprintf( pFile, "%s", (Level==0? "" : ")") );
        }
        else 
        {
            pFaninC = Hop_ObjRecognizeMux( pObj, &pFanin1, &pFanin0 );
            fprintf( pFile, "%s", (Level==0? "" : "(") );
            Hop_ObjPrintVerilog( pFile, pFaninC, vLevels, Level+1 );
            fprintf( pFile, " ? " );
            Hop_ObjPrintVerilog( pFile, Hop_NotCond(pFanin1, fCompl), vLevels, Level+1 );
            fprintf( pFile, " : " );
            Hop_ObjPrintVerilog( pFile, Hop_NotCond(pFanin0, fCompl), vLevels, Level+1 );
            fprintf( pFile, "%s", (Level==0? "" : ")") );
        }
        return;
    }
    // AND case
    Vec_VecExpand( vLevels, Level );
    vSuper = Vec_VecEntry(vLevels, Level);
    Hop_ObjCollectMulti( pObj, vSuper );
    fprintf( pFile, "%s", (Level==0? "" : "(") );
    Vec_PtrForEachEntry( Hop_Obj_t *, vSuper, pFanin, i )
    {
        Hop_ObjPrintVerilog( pFile, Hop_NotCond(pFanin, fCompl), vLevels, Level+1 );
        if ( i < Vec_PtrSize(vSuper) - 1 )
            fprintf( pFile, " %s ", fCompl? "|" : "&" );
    }
    fprintf( pFile, "%s", (Level==0? "" : ")") );
    return;
}

int Hop_ObjRecognizeExor	(	Hop_Obj_t *	pObj,
		Hop_Obj_t **	ppFan0,
		Hop_Obj_t **	ppFan1
	)

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

Synopsis [Recognizes what nodes are inputs of the EXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 187 of file hopUtil.c.

{
    Hop_Obj_t * p0, * p1;
    assert( !Hop_IsComplement(pObj) );
    if ( !Hop_ObjIsNode(pObj) )
        return 0;
    if ( Hop_ObjIsExor(pObj) )
    {
        *ppFan0 = Hop_ObjChild0(pObj);
        *ppFan1 = Hop_ObjChild1(pObj);
        return 1;
    }
    assert( Hop_ObjIsAnd(pObj) );
    p0 = Hop_ObjChild0(pObj);
    p1 = Hop_ObjChild1(pObj);
    if ( !Hop_IsComplement(p0) || !Hop_IsComplement(p1) )
        return 0;
    p0 = Hop_Regular(p0);
    p1 = Hop_Regular(p1);
    if ( !Hop_ObjIsAnd(p0) || !Hop_ObjIsAnd(p1) )
        return 0;
    if ( Hop_ObjFanin0(p0) != Hop_ObjFanin0(p1) || Hop_ObjFanin1(p0) != Hop_ObjFanin1(p1) )
        return 0;
    if ( Hop_ObjFaninC0(p0) == Hop_ObjFaninC0(p1) || Hop_ObjFaninC1(p0) == Hop_ObjFaninC1(p1) )
        return 0;
    *ppFan0 = Hop_ObjChild0(p0);
    *ppFan1 = Hop_ObjChild1(p0);
    return 1;
}

Hop_Obj_t* Hop_ObjRecognizeMux	(	Hop_Obj_t *	pNode,
		Hop_Obj_t **	ppNodeT,
		Hop_Obj_t **	ppNodeE
	)

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

Synopsis [Recognizes what nodes are control and data inputs of a MUX.]

Description [If the node is a MUX, returns the control variable C. Assigns nodes T and E to be the then and else variables of the MUX. Node C is never complemented. Nodes T and E can be complemented. This function also recognizes EXOR/NEXOR gates as MUXes.]

SideEffects []

SeeAlso []

Definition at line 231 of file hopUtil.c.

{
    Hop_Obj_t * pNode0, * pNode1;
    assert( !Hop_IsComplement(pNode) );
    assert( Hop_ObjIsMuxType(pNode) );
    // get children
    pNode0 = Hop_ObjFanin0(pNode);
    pNode1 = Hop_ObjFanin1(pNode);

    // find the control variable
    if ( Hop_ObjFanin1(pNode0) == Hop_ObjFanin1(pNode1) && (Hop_ObjFaninC1(pNode0) ^ Hop_ObjFaninC1(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p2) )
        if ( Hop_ObjFaninC1(pNode0) )
        { // pNode2->p2 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild0(pNode1));//pNode2->p1);
            *ppNodeE = Hop_Not(Hop_ObjChild0(pNode0));//pNode1->p1);
            return Hop_ObjChild1(pNode1);//pNode2->p2;
        }
        else
        { // pNode1->p2 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild0(pNode0));//pNode1->p1);
            *ppNodeE = Hop_Not(Hop_ObjChild0(pNode1));//pNode2->p1);
            return Hop_ObjChild1(pNode0);//pNode1->p2;
        }
    }
    else if ( Hop_ObjFanin0(pNode0) == Hop_ObjFanin0(pNode1) && (Hop_ObjFaninC0(pNode0) ^ Hop_ObjFaninC0(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p1) )
        if ( Hop_ObjFaninC0(pNode0) )
        { // pNode2->p1 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild1(pNode1));//pNode2->p2);
            *ppNodeE = Hop_Not(Hop_ObjChild1(pNode0));//pNode1->p2);
            return Hop_ObjChild0(pNode1);//pNode2->p1;
        }
        else
        { // pNode1->p1 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild1(pNode0));//pNode1->p2);
            *ppNodeE = Hop_Not(Hop_ObjChild1(pNode1));//pNode2->p2);
            return Hop_ObjChild0(pNode0);//pNode1->p1;
        }
    }
    else if ( Hop_ObjFanin0(pNode0) == Hop_ObjFanin1(pNode1) && (Hop_ObjFaninC0(pNode0) ^ Hop_ObjFaninC1(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p1) )
        if ( Hop_ObjFaninC0(pNode0) )
        { // pNode2->p2 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild0(pNode1));//pNode2->p1);
            *ppNodeE = Hop_Not(Hop_ObjChild1(pNode0));//pNode1->p2);
            return Hop_ObjChild1(pNode1);//pNode2->p2;
        }
        else
        { // pNode1->p1 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild1(pNode0));//pNode1->p2);
            *ppNodeE = Hop_Not(Hop_ObjChild0(pNode1));//pNode2->p1);
            return Hop_ObjChild0(pNode0);//pNode1->p1;
        }
    }
    else if ( Hop_ObjFanin1(pNode0) == Hop_ObjFanin0(pNode1) && (Hop_ObjFaninC1(pNode0) ^ Hop_ObjFaninC0(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p2) )
        if ( Hop_ObjFaninC1(pNode0) )
        { // pNode2->p1 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild1(pNode1));//pNode2->p2);
            *ppNodeE = Hop_Not(Hop_ObjChild0(pNode0));//pNode1->p1);
            return Hop_ObjChild0(pNode1);//pNode2->p1;
        }
        else
        { // pNode1->p2 is positive phase of C
            *ppNodeT = Hop_Not(Hop_ObjChild0(pNode0));//pNode1->p1);
            *ppNodeE = Hop_Not(Hop_ObjChild1(pNode1));//pNode2->p2);
            return Hop_ObjChild1(pNode0);//pNode1->p2;
        }
    }
    assert( 0 ); // this is not MUX
    return NULL;
}

static void Hop_ObjRef ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 177 of file hop.h.

{ pObj->nRefs++;                                 }

static int Hop_ObjRefs ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 176 of file hop.h.

{ return pObj->nRefs;                            }

Hop_Obj_t* Hop_ObjRepr

(

Hop_Obj_t *

pObj

)

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

Synopsis [Returns the representative of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 241 of file hopObj.c.

{
    assert( !Hop_IsComplement(pObj) );
    if ( pObj->pData == NULL || pObj->pData == pObj )
        return pObj;
    return Hop_ObjRepr( (Hop_Obj_t *)pObj->pData );
}

static void Hop_ObjSetMarkA ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 165 of file hop.h.

{ pObj->fMarkA = 1;     }

static void Hop_ObjSetTravId ( Hop_Obj_t *  pObj, int  TravId  )

inlinestatic

Definition at line 168 of file hop.h.

{ pObj->pData = (void *)(ABC_PTRINT_T)TravId;                      }

static void Hop_ObjSetTravIdCurrent ( Hop_Man_t *  p, Hop_Obj_t *  pObj  )

inlinestatic

Definition at line 169 of file hop.h.

{ pObj->pData = (void *)(ABC_PTRINT_T)p->nTravIds;                 }

static void Hop_ObjSetTravIdPrevious ( Hop_Man_t *  p, Hop_Obj_t *  pObj  )

inlinestatic

Definition at line 170 of file hop.h.

{ pObj->pData = (void *)(ABC_PTRINT_T)(p->nTravIds - 1);           }

static int Hop_ObjTravId ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 174 of file hop.h.

{ return (int)(ABC_PTRINT_T)pObj->pData;        }

static Hop_Type_t Hop_ObjType ( Hop_Obj_t *  pObj )

inlinestatic

Definition at line 153 of file hop.h.

{ return (Hop_Type_t)pObj->Type;               }

static int Hop_ObjWhatFanin ( Hop_Obj_t *  pObj, Hop_Obj_t *  pFanin  )

inlinestatic

Definition at line 194 of file hop.h.

{ 
    if ( Hop_ObjFanin0(pObj) == pFanin ) return 0; 
    if ( Hop_ObjFanin1(pObj) == pFanin ) return 1; 
    assert(0); return -1; 
}

Hop_Obj_t* Hop_Oper	(	Hop_Man_t *	p,
		Hop_Obj_t *	p0,
		Hop_Obj_t *	p1,
		Hop_Type_t	Type
	)

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

Synopsis [Perform one operation.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 83 of file hopOper.c.

{
    if ( Type == AIG_AND )
        return Hop_And( p, p0, p1 );
    if ( Type == AIG_EXOR )
        return Hop_Exor( p, p0, p1 );
    assert( 0 );
    return NULL;
}

Hop_Obj_t* Hop_Or	(	Hop_Man_t *	p,
		Hop_Obj_t *	p0,
		Hop_Obj_t *	p1
	)

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

Synopsis [Implements Boolean OR.]

Description []

SideEffects []

SeeAlso []

Definition at line 171 of file hopOper.c.

{
    return Hop_Not( Hop_And( p, Hop_Not(p0), Hop_Not(p1) ) );
}

Hop_Obj_t* Hop_Permute	(	Hop_Man_t *	p,
		Hop_Obj_t *	pRoot,
		int	nRootVars,
		int *	pPermute
	)

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

Synopsis [Permute the AIG according to the given permutation.]

Description []

SideEffects []

SeeAlso []

Definition at line 563 of file hopDfs.c.

{
    Hop_Obj_t * pObj;
    int i;
    // return if constant
    if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
        return pRoot;
    // create mapping
    Hop_ManForEachPi( p, pObj, i )
    {
        if ( i == nRootVars )
            break;
        assert( pPermute[i] >= 0 && pPermute[i] < Hop_ManPiNum(p) );
        pObj->pData = Hop_IthVar( p, pPermute[i] );
    }
    // recursively perform composition
    Hop_Remap_rec( p, Hop_Regular(pRoot) );
    // clear the markings
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    return Hop_NotCond( (Hop_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );
}

static Hop_Obj_t* Hop_Regular ( Hop_Obj_t *  p )

inlinestatic

Definition at line 126 of file hop.h.

{ return (Hop_Obj_t *)((ABC_PTRUINT_T)(p) & ~01); }

Hop_Obj_t* Hop_Remap	(	Hop_Man_t *	p,
		Hop_Obj_t *	pRoot,
		unsigned	uSupp,
		int	nVars
	)

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

Synopsis [Remaps the AIG (pRoot) to have the given support (uSupp).]

Description []

SideEffects []

SeeAlso []

Definition at line 518 of file hopDfs.c.

{
    Hop_Obj_t * pObj;
    int i, k;
    // quit if the PI variable is not defined
    if ( nVars > Hop_ManPiNum(p) )
    {
        printf( "Hop_Remap(): The number of variables (%d) is more than the manager size (%d).\n", nVars, Hop_ManPiNum(p) );
        return NULL;
    }
    // return if constant
    if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
        return pRoot;
    if ( uSupp == 0 )
        return Hop_NotCond( Hop_ManConst0(p), Hop_ObjPhaseCompl(pRoot) );
    // set the PI mapping
    k = 0;
    Hop_ManForEachPi( p, pObj, i )
    {
        if ( i == nVars )
           break;
        if ( uSupp & (1 << i) )
            pObj->pData = Hop_IthVar(p, k++);
        else
            pObj->pData = Hop_ManConst0(p);
    }
    assert( k > 0 && k < nVars );
    // recursively perform composition
    Hop_Remap_rec( p, Hop_Regular(pRoot) );
    // clear the markings
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    return Hop_NotCond( (Hop_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );
}

int Hop_TableCountEntries

(

Hop_Man_t *

p

)

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

Synopsis [Count the number of nodes in the table.]

Description []

SideEffects []

SeeAlso []

Definition at line 145 of file hopTable.c.

{
    Hop_Obj_t * pEntry;
    int i, Counter = 0;
    for ( i = 0; i < p->nTableSize; i++ )
        for ( pEntry = p->pTable[i]; pEntry; pEntry = pEntry->pNext )
            Counter++;
    return Counter;
}

void Hop_TableDelete	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj
	)

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

Synopsis [Deletes the node from the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 123 of file hopTable.c.

{
    Hop_Obj_t ** ppPlace;
    assert( !Hop_IsComplement(pObj) );
    ppPlace = Hop_TableFind( p, pObj );
    assert( *ppPlace == pObj ); // node should be in the table
    // remove the node
    *ppPlace = pObj->pNext;
    pObj->pNext = NULL;
}

void Hop_TableInsert	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj
	)

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

Synopsis [Adds the new node to the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 100 of file hopTable.c.

{
    Hop_Obj_t ** ppPlace;
    assert( !Hop_IsComplement(pObj) );
    assert( Hop_TableLookup(p, pObj) == NULL );
    if ( (pObj->Id & 0xFF) == 0 && 2 * p->nTableSize < Hop_ManNodeNum(p) )
        Hop_TableResize( p );
    ppPlace = Hop_TableFind( p, pObj );
    assert( *ppPlace == NULL );
    *ppPlace = pObj;
}

Hop_Obj_t* Hop_TableLookup	(	Hop_Man_t *	p,
		Hop_Obj_t *	pGhost
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Checks if a node with the given attributes is in the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file hopTable.c.

{
    Hop_Obj_t * pEntry;
    assert( !Hop_IsComplement(pGhost) );
    assert( Hop_ObjChild0(pGhost) && Hop_ObjChild1(pGhost) );
    assert( Hop_ObjFanin0(pGhost)->Id < Hop_ObjFanin1(pGhost)->Id );
    if ( p->fRefCount && (!Hop_ObjRefs(Hop_ObjFanin0(pGhost)) || !Hop_ObjRefs(Hop_ObjFanin1(pGhost))) )
        return NULL;
    for ( pEntry = p->pTable[Hop_Hash(pGhost, p->nTableSize)]; pEntry; pEntry = pEntry->pNext )
    {
        if ( Hop_ObjChild0(pEntry) == Hop_ObjChild0(pGhost) && 
             Hop_ObjChild1(pEntry) == Hop_ObjChild1(pGhost) && 
             Hop_ObjType(pEntry) == Hop_ObjType(pGhost) )
            return pEntry;
    }
    return NULL;
}

void Hop_TableProfile

(

Hop_Man_t *

p

)

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

Synopsis [Profiles the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 212 of file hopTable.c.

{
    Hop_Obj_t * pEntry;
    int i, Counter;
    for ( i = 0; i < p->nTableSize; i++ )
    {
        Counter = 0;
        for ( pEntry = p->pTable[i]; pEntry; pEntry = pEntry->pNext )
            Counter++;
        if ( Counter ) 
            printf( "%d ", Counter );
    }
}

Hop_Obj_t* Hop_Transfer	(	Hop_Man_t *	pSour,
		Hop_Man_t *	pDest,
		Hop_Obj_t *	pRoot,
		int	nVars
	)

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

Synopsis [Transfers the AIG from one manager into another.]

Description []

SideEffects []

SeeAlso []

Definition at line 353 of file hopDfs.c.

{
    Hop_Obj_t * pObj;
    int i;
    // solve simple cases
    if ( pSour == pDest )
        return pRoot;
    if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
        return Hop_NotCond( Hop_ManConst1(pDest), Hop_IsComplement(pRoot) );
    // set the PI mapping
    Hop_ManForEachPi( pSour, pObj, i )
    {
        if ( i == nVars )
           break;
        pObj->pData = Hop_IthVar(pDest, i);
    }
    // transfer and set markings
    Hop_Transfer_rec( pDest, Hop_Regular(pRoot) );
    // clear the markings
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    return Hop_NotCond( (Hop_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );
}

static int Hop_TruthWordNum ( int  nVars )

inlinestatic

Definition at line 119 of file hop.h.

{ return nVars <= 5 ? 1 : (1 << (nVars - 5));     }