amapInt.h File Reference

#include "misc/extra/extra.h"
#include "aig/aig/aig.h"
#include "amap.h"

Go to the source code of this file.

Data Structures
struct	Amap_Man_t_
struct	Amap_Lib_t_
struct	Amap_Pin_t_
struct	Amap_Gat_t_
struct	Amap_Set_t_
struct	Amap_Nod_t_
struct	Amap_Cut_t_
struct	Amap_Mat_t_
struct	Amap_Obj_t_

Macros
#define	AMAP_MAXINS   15
	INCLUDES ///. More...
#define	AMAP_STRING_CONST0   "CONST0"
#define	AMAP_STRING_CONST1   "CONST1"
#define	Amap_ManForEachPi(p, pObj, i)   Vec_PtrForEachEntry( Amap_Obj_t *, p->vPis, pObj, i )
	MACRO DEFINITIONS ///. More...
#define	Amap_ManForEachPo(p, pObj, i)   Vec_PtrForEachEntry( Amap_Obj_t *, p->vPos, pObj, i )
#define	Amap_ManForEachObj(p, pObj, i)   Vec_PtrForEachEntry( Amap_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL ) {} else
#define	Amap_ManForEachNode(p, pObj, i)   Vec_PtrForEachEntry( Amap_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL || !Amap_ObjIsNode(pObj) ) {} else
#define	Amap_LibForEachGate(pLib, pGate, i)   Vec_PtrForEachEntry( Amap_Gat_t *, pLib->vGates, pGate, i )
#define	Amap_GateForEachPin(pGate, pPin)   for ( pPin = pGate->Pins; pPin < pGate->Pins + pGate->nPins; pPin++ )
#define	Amap_NodeForEachCut(pNode, pCut, i)
#define	Amap_LibNodeForEachSet(pNod, pSet)   for ( pSet = pNod->pSets; pSet; pSet = pSet->pNext )
#define	Amap_MatchForEachFaninCompl(p, pM, pFanin, fCompl, i)
#define	Amap_MatchForEachFanin(p, pM, pFanin, i)

Typedefs
typedef struct Amap_Pin_t_	Amap_Pin_t
	BASIC TYPES ///. More...
typedef struct Amap_Gat_t_	Amap_Gat_t
typedef struct Amap_Nod_t_	Amap_Nod_t
typedef struct Amap_Set_t_	Amap_Set_t
typedef struct Amap_Man_t_	Amap_Man_t
typedef struct Amap_Obj_t_	Amap_Obj_t
typedef struct Amap_Cut_t_	Amap_Cut_t
typedef struct Amap_Mat_t_	Amap_Mat_t

Enumerations
enum	Amap_Type_t {   AMAP_OBJ_NONE, AMAP_OBJ_CONST1, AMAP_OBJ_PI, AMAP_OBJ_PO,   AMAP_OBJ_AND, AMAP_OBJ_XOR, AMAP_OBJ_MUX, AMAP_OBJ_VOID }

Functions
static Amap_Obj_t *	Amap_Regular (Amap_Obj_t *p)
static Amap_Obj_t *	Amap_Not (Amap_Obj_t *p)
static Amap_Obj_t *	Amap_NotCond (Amap_Obj_t *p, int c)
static int	Amap_IsComplement (Amap_Obj_t *p)
static int	Amap_ManPiNum (Amap_Man_t *p)
static int	Amap_ManPoNum (Amap_Man_t *p)
static int	Amap_ManAndNum (Amap_Man_t *p)
static int	Amap_ManXorNum (Amap_Man_t *p)
static int	Amap_ManMuxNum (Amap_Man_t *p)
static int	Amap_ManObjNum (Amap_Man_t *p)
static int	Amap_ManNodeNum (Amap_Man_t *p)
static Amap_Obj_t *	Amap_ManConst1 (Amap_Man_t *p)
static Amap_Obj_t *	Amap_ManPi (Amap_Man_t *p, int i)
static Amap_Obj_t *	Amap_ManPo (Amap_Man_t *p, int i)
static Amap_Obj_t *	Amap_ManObj (Amap_Man_t *p, int i)
static int	Amap_ObjIsConst1 (Amap_Obj_t *pObj)
static int	Amap_ObjIsPi (Amap_Obj_t *pObj)
static int	Amap_ObjIsPo (Amap_Obj_t *pObj)
static int	Amap_ObjIsAnd (Amap_Obj_t *pObj)
static int	Amap_ObjIsXor (Amap_Obj_t *pObj)
static int	Amap_ObjIsMux (Amap_Obj_t *pObj)
static int	Amap_ObjIsNode (Amap_Obj_t *pObj)
static int	Amap_ObjToLit (Amap_Obj_t *pObj)
static Amap_Obj_t *	Amap_ObjFanin0 (Amap_Man_t *p, Amap_Obj_t *pObj)
static Amap_Obj_t *	Amap_ObjFanin1 (Amap_Man_t *p, Amap_Obj_t *pObj)
static Amap_Obj_t *	Amap_ObjFanin2 (Amap_Man_t *p, Amap_Obj_t *pObj)
static int	Amap_ObjFaninC0 (Amap_Obj_t *pObj)
static int	Amap_ObjFaninC1 (Amap_Obj_t *pObj)
static int	Amap_ObjFaninC2 (Amap_Obj_t *pObj)
static void *	Amap_ObjCopy (Amap_Obj_t *pObj)
static int	Amap_ObjLevel (Amap_Obj_t *pObj)
static void	Amap_ObjSetLevel (Amap_Obj_t *pObj, int Level)
static void	Amap_ObjSetCopy (Amap_Obj_t *pObj, void *pCopy)
static Amap_Obj_t *	Amap_ObjChoice (Amap_Man_t *p, Amap_Obj_t *pObj)
static void	Amap_ObjSetChoice (Amap_Obj_t *pObj, Amap_Obj_t *pEqu)
static int	Amap_ObjPhaseReal (Amap_Obj_t *pObj)
static int	Amap_ObjRefsTotal (Amap_Obj_t *pObj)
static Amap_Gat_t *	Amap_LibGate (Amap_Lib_t *p, int i)
static Amap_Nod_t *	Amap_LibNod (Amap_Lib_t *p, int i)
static Amap_Cut_t *	Amap_ManCutNext (Amap_Cut_t *pCut)
static Amap_Cut_t **	Amap_ManCutNextP (Amap_Cut_t *pCut)
void	Kit_DsdPrintFromTruth (unsigned *pTruth, int nVars)
Amap_Obj_t *	Amap_ManCreatePi (Amap_Man_t *p)
	FUNCTION DECLARATIONS ///. More...
Amap_Obj_t *	Amap_ManCreatePo (Amap_Man_t *p, Amap_Obj_t *pFan0)
Amap_Obj_t *	Amap_ManCreateAnd (Amap_Man_t *p, Amap_Obj_t *pFan0, Amap_Obj_t *pFan1)
Amap_Obj_t *	Amap_ManCreateXor (Amap_Man_t *p, Amap_Obj_t *pFan0, Amap_Obj_t *pFan1)
Amap_Obj_t *	Amap_ManCreateMux (Amap_Man_t *p, Amap_Obj_t *pFanC, Amap_Obj_t *pFan1, Amap_Obj_t *pFan0)
void	Amap_ManCreateChoice (Amap_Man_t *p, Amap_Obj_t *pObj)
void	Amap_ManCreate (Amap_Man_t *p, Aig_Man_t *pAig)
Amap_Lib_t *	Amap_LibAlloc ()
	DECLARATIONS ///. More...
int	Amap_LibNumPinsMax (Amap_Lib_t *p)
void	Amap_LibWrite (FILE *pFile, Amap_Lib_t *pLib, int fPrintDsd)
Vec_Ptr_t *	Amap_LibSelectGates (Amap_Lib_t *p, int fVerbose)
Amap_Man_t *	Amap_ManStart (int nNodes)
	DECLARATIONS ///. More...
void	Amap_ManStop (Amap_Man_t *p)
void	Amap_ManMap (Amap_Man_t *p)
void	Amap_ManMerge (Amap_Man_t *p)
Vec_Ptr_t *	Amap_ManProduceMapped (Amap_Man_t *p)
int	Amap_LibParseEquations (Amap_Lib_t *p, int fVerbose)
Amap_Lib_t *	Amap_LibReadBuffer (char *pBuffer, int fVerbose)
Amap_Lib_t *	Amap_LibReadFile (char *pFileName, int fVerbose)
short *	Amap_LibTableFindNode (Amap_Lib_t *p, int iFan0, int iFan1, int fXor)
void	Amap_LibCreateRules (Amap_Lib_t *p, int fVeryVerbose)
int	Amap_LibFindNode (Amap_Lib_t *pLib, int iFan0, int iFan1, int fXor)
int	Amap_LibFindMux (Amap_Lib_t *p, int iFan0, int iFan1, int iFan2)
int	Amap_LibCreateVar (Amap_Lib_t *p)
int	Amap_LibCreateNode (Amap_Lib_t *p, int iFan0, int iFan1, int fXor)
int	Amap_LibCreateMux (Amap_Lib_t *p, int iFan0, int iFan1, int iFan2)
int **	Amap_LibLookupTableAlloc (Vec_Ptr_t *vVec, int fVerbose)

Macro Definition Documentation

#define Amap_GateForEachPin	(		pGate,
			pPin
	)		for ( pPin = pGate->Pins; pPin < pGate->Pins + pGate->nPins; pPin++ )

Definition at line 296 of file amapInt.h.

#define Amap_LibForEachGate	(		pLib,
			pGate,
			i
	)		Vec_PtrForEachEntry( Amap_Gat_t *, pLib->vGates, pGate, i )

Definition at line 293 of file amapInt.h.

#define Amap_LibNodeForEachSet	(		pNod,
			pSet
	)		for ( pSet = pNod->pSets; pSet; pSet = pSet->pNext )

Definition at line 305 of file amapInt.h.

#define Amap_ManForEachNode	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Amap_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL || !Amap_ObjIsNode(pObj) ) {} else

Definition at line 289 of file amapInt.h.

#define Amap_ManForEachObj	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Amap_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL ) {} else

Definition at line 286 of file amapInt.h.

#define Amap_ManForEachPi	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Amap_Obj_t *, p->vPis, pObj, i )

MACRO DEFINITIONS ///.

Definition at line 280 of file amapInt.h.

#define Amap_ManForEachPo	(		p,
			pObj,
			i
	)		Vec_PtrForEachEntry( Amap_Obj_t *, p->vPos, pObj, i )

Definition at line 283 of file amapInt.h.

#define Amap_MatchForEachFanin	(		p,
			pM,
			pFanin,
			i
	)

Value:

for ( i = 0; i < (int)(pM)->pCut->nFans &&                             \
        ((pFanin = Amap_ManObj((p), Abc_Lit2Var((pM)->pCut->Fans[Abc_Lit2Var((pM)->pSet->Ins[i])]))), 1); \
        i++ )

Definition at line 316 of file amapInt.h.

#define Amap_MatchForEachFaninCompl	(		p,
			pM,
			pFanin,
			fCompl,
			i
	)

Value:

for ( i = 0; i < (int)(pM)->pCut->nFans &&                             \
        ((pFanin = Amap_ManObj((p), Abc_Lit2Var((pM)->pCut->Fans[Abc_Lit2Var((pM)->pSet->Ins[i])]))), 1) && \
        ((fCompl = Abc_LitIsCompl((pM)->pSet->Ins[i]) ^ Abc_LitIsCompl((pM)->pCut->Fans[Abc_Lit2Var((pM)->pSet->Ins[i])])), 1); \
        i++ )

Definition at line 309 of file amapInt.h.

#define AMAP_MAXINS   15

INCLUDES ///.

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

FileName [amapInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Technology mapper for standard cells.]

Synopsis [Internal declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:

amapInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

]PARAMETERS ///

Definition at line 44 of file amapInt.h.

#define Amap_NodeForEachCut	(		pNode,
			pCut,
			i
	)

Value:

for ( i = 0, pCut = (Amap_Cut_t *)pNode->pData; i < (int)pNode->nCuts; \
        i++, pCut = Amap_ManCutNext(pCut) )

Definition at line 300 of file amapInt.h.

#define AMAP_STRING_CONST0   "CONST0"

Definition at line 46 of file amapInt.h.

#define AMAP_STRING_CONST1   "CONST1"

Definition at line 47 of file amapInt.h.

Typedef Documentation

typedef struct Amap_Cut_t_ Amap_Cut_t

Definition at line 72 of file amapInt.h.

typedef struct Amap_Gat_t_ Amap_Gat_t

Definition at line 66 of file amapInt.h.

typedef struct Amap_Man_t_ Amap_Man_t

Definition at line 70 of file amapInt.h.

typedef struct Amap_Mat_t_ Amap_Mat_t

Definition at line 73 of file amapInt.h.

typedef struct Amap_Nod_t_ Amap_Nod_t

Definition at line 67 of file amapInt.h.

typedef struct Amap_Obj_t_ Amap_Obj_t

Definition at line 71 of file amapInt.h.

typedef struct Amap_Pin_t_ Amap_Pin_t

BASIC TYPES ///.

Definition at line 65 of file amapInt.h.

typedef struct Amap_Set_t_ Amap_Set_t

Definition at line 68 of file amapInt.h.

Enumeration Type Documentation

enum Amap_Type_t

Enumerator
AMAP_OBJ_NONE
AMAP_OBJ_CONST1
AMAP_OBJ_PI
AMAP_OBJ_PO
AMAP_OBJ_AND
AMAP_OBJ_XOR
AMAP_OBJ_MUX
AMAP_OBJ_VOID

Definition at line 50 of file amapInt.h.

             { 
    AMAP_OBJ_NONE,    // 0: non-existent object
    AMAP_OBJ_CONST1,  // 1: constant 1 
    AMAP_OBJ_PI,      // 2: primary input
    AMAP_OBJ_PO,      // 3: primary output
    AMAP_OBJ_AND,     // 4: AND node
    AMAP_OBJ_XOR,     // 5: XOR node
    AMAP_OBJ_MUX,     // 6: MUX node
    AMAP_OBJ_VOID     // 7: unused object
} Amap_Type_t;

Function Documentation

static int Amap_IsComplement ( Amap_Obj_t *  p )

inlinestatic

Definition at line 224 of file amapInt.h.

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

Amap_Lib_t* Amap_LibAlloc

(

)

DECLARATIONS ///.

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

FileName [amapLib.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Technology mapper for standard cells.]

Synopsis [Standard-cell library.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:

amapLib.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

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

Synopsis [Allocs a library.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file amapLib.c.

{
    Amap_Lib_t * p;
    p = (Amap_Lib_t *)ABC_ALLOC( Amap_Lib_t, 1 );
    memset( p, 0, sizeof(Amap_Lib_t) );
    p->vGates = Vec_PtrAlloc( 100 );
    p->pMemGates = Aig_MmFlexStart();
    p->pMemSet = Aig_MmFlexStart();
    return p;
}

int Amap_LibCreateMux	(	Amap_Lib_t *	p,
		int	iFan0,
		int	iFan1,
		int	iFan2
	)

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

Synopsis [Creates a new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 244 of file amapUniq.c.

{
    Amap_Nod_t * pNode;
    pNode = Amap_LibCreateObj( p );
    pNode->Type  = AMAP_OBJ_MUX;
    pNode->nSuppSize = p->pNodes[Abc_Lit2Var(iFan0)].nSuppSize + p->pNodes[Abc_Lit2Var(iFan1)].nSuppSize + p->pNodes[Abc_Lit2Var(iFan2)].nSuppSize;
    pNode->iFan0 = iFan0;
    pNode->iFan1 = iFan1;
    pNode->iFan2 = iFan2;
if ( p->fVerbose )
printf( "Creating node %5d %c :  iFan0 = %5d%c  iFan1 = %5d%c  iFan2 = %5d%c\n", 
pNode->Id, 'm', 
Abc_Lit2Var(iFan0), (Abc_LitIsCompl(iFan0)?'-':'+'), 
Abc_Lit2Var(iFan1), (Abc_LitIsCompl(iFan1)?'-':'+'), 
Abc_Lit2Var(iFan2), (Abc_LitIsCompl(iFan2)?'-':'+') );

    Vec_IntPush( p->vRules3, iFan0 );
    Vec_IntPush( p->vRules3, iFan1 );
    Vec_IntPush( p->vRules3, iFan2 );
    Vec_IntPush( p->vRules3, pNode->Id );
    return pNode->Id;
}

int Amap_LibCreateNode	(	Amap_Lib_t *	p,
		int	iFan0,
		int	iFan1,
		int	fXor
	)

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

Synopsis [Creates a new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 189 of file amapUniq.c.

{
    Amap_Nod_t * pNode;
    int iFan;
    if ( iFan0 < iFan1 )
    {
        iFan  = iFan0;
        iFan0 = iFan1;
        iFan1 = iFan;
    }
    pNode = Amap_LibCreateObj( p );
    pNode->Type  = fXor? AMAP_OBJ_XOR : AMAP_OBJ_AND;
    pNode->nSuppSize = p->pNodes[Abc_Lit2Var(iFan0)].nSuppSize + p->pNodes[Abc_Lit2Var(iFan1)].nSuppSize;
    pNode->iFan0 = iFan0;
    pNode->iFan1 = iFan1;
if ( p->fVerbose )
printf( "Creating node %5d %c :  iFan0 = %5d%c  iFan1 = %5d%c\n", 
pNode->Id, (fXor?'x':' '), 
Abc_Lit2Var(iFan0), (Abc_LitIsCompl(iFan0)?'-':'+'), 
Abc_Lit2Var(iFan1), (Abc_LitIsCompl(iFan1)?'-':'+') );

    if ( fXor )
    {
        if ( iFan0 == iFan1 )
            Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRulesX, iFan0), (pNode->Id << 16) | iFan1 );
        else
        {
            Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRulesX, iFan0), (pNode->Id << 16) | iFan1 );
            Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRulesX, iFan1), (pNode->Id << 16) | iFan0 );
        }
    }
    else
    {
        if ( iFan0 == iFan1 )
            Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRules, iFan0), (pNode->Id << 16) | iFan1 );
        else
        {
            Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRules, iFan0), (pNode->Id << 16) | iFan1 );
            Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRules, iFan1), (pNode->Id << 16) | iFan0 );
        }
    }
    return pNode->Id;
}

void Amap_LibCreateRules	(	Amap_Lib_t *	pLib,
		int	fVeryVerbose
	)

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

Synopsis [Creates rules for the given gate]

Description []

SideEffects []

SeeAlso []

Definition at line 426 of file amapRule.c.

{
    Amap_Gat_t * pGate;
    int i, nGates = 0;
//    abctime clk = Abc_Clock();
    pLib->fVerbose = fVeryVerbose;
    pLib->vRules   = Vec_PtrAlloc( 100 );
    pLib->vRulesX  = Vec_PtrAlloc( 100 );
    pLib->vRules3  = Vec_IntAlloc( 100 );
    Amap_LibCreateVar( pLib );
    Vec_PtrForEachEntry( Amap_Gat_t *, pLib->vSelect, pGate, i )
    {
        if ( pGate->nPins < 2 )
            continue;
        if ( pGate->pFunc == NULL )
        {
            printf( "Amap_LibCreateRules(): Skipping gate %s (%s).\n", pGate->pName, pGate->pForm );
            continue;
        }
        Amap_CreateRulesForGate( pLib, pGate );
        nGates++;
    }
    assert( Vec_PtrSize(pLib->vRules)  == 2*pLib->nNodes );
    assert( Vec_PtrSize(pLib->vRulesX) == 2*pLib->nNodes );
    pLib->pRules  = Amap_LibLookupTableAlloc( pLib->vRules, 0 );
    pLib->pRulesX = Amap_LibLookupTableAlloc( pLib->vRulesX, 0 );
    Vec_VecFree( (Vec_Vec_t *)pLib->vRules );  pLib->vRules  = NULL;
    Vec_VecFree( (Vec_Vec_t *)pLib->vRulesX ); pLib->vRulesX = NULL;
}

int Amap_LibCreateVar

(

Amap_Lib_t *

p

)

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

Synopsis [Creates a new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 164 of file amapUniq.c.

{
    Amap_Nod_t * pNode;
    // start the manager
    assert( p->pNodes == NULL );
    p->nNodesAlloc = 256;
    p->pNodes = ABC_ALLOC( Amap_Nod_t, p->nNodesAlloc );
    // create the first node
    pNode = Amap_LibCreateObj( p );
    p->pNodes->Type = AMAP_OBJ_PI;
    p->pNodes->nSuppSize = 1;
    return 0;
}

int Amap_LibFindMux	(	Amap_Lib_t *	p,
		int	iFan0,
		int	iFan1,
		int	iFan2
	)

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

Synopsis [Checks if the three-argument rule exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 109 of file amapUniq.c.

{
    int x;
    for ( x = 0; x < Vec_IntSize(p->vRules3); x += 4 )
    {
        if ( Vec_IntEntry(p->vRules3, x)   == iFan0 &&
             Vec_IntEntry(p->vRules3, x+1) == iFan1 &&
             Vec_IntEntry(p->vRules3, x+2) == iFan2 )
        {
            return Vec_IntEntry(p->vRules3, x+3);
        }
    }
    return -1;
}

int Amap_LibFindNode	(	Amap_Lib_t *	pLib,
		int	iFan0,
		int	iFan1,
		int	fXor
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 90 of file amapUniq.c.

{
    if ( fXor )
        return Vec_IntCheckWithMask( (Vec_Int_t *)Vec_PtrEntry(pLib->vRulesX, iFan0), iFan1 );
    else
        return Vec_IntCheckWithMask( (Vec_Int_t *)Vec_PtrEntry(pLib->vRules, iFan0), iFan1 );
}

static Amap_Gat_t* Amap_LibGate ( Amap_Lib_t *  p, int  i  )

inlinestatic

Definition at line 263 of file amapInt.h.

{ return (Amap_Gat_t *)Vec_PtrEntry(p->vGates, i); }

int** Amap_LibLookupTableAlloc	(	Vec_Ptr_t *	vVec,
		int	fVerbose
	)

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

Synopsis [Allocates triangular lookup table.]

Description []

SideEffects []

SeeAlso []

Definition at line 278 of file amapUniq.c.

{
    Vec_Int_t * vOne;
    int ** pRes, * pBuffer;
    int i, k, nTotal, nSize, nEntries, Value;
    // count the total size
    nEntries = nSize = Vec_PtrSize( vVec );
    Vec_PtrForEachEntry( Vec_Int_t *, vVec, vOne, i )
        nEntries += Vec_IntSize(vOne);
    pBuffer = ABC_ALLOC( int, nSize * sizeof(void *) + nEntries );
    pRes = (int **)pBuffer;
    pRes[0] = pBuffer + nSize * sizeof(void *);
    nTotal = 0;
    Vec_PtrForEachEntry( Vec_Int_t *, vVec, vOne, i )
    {
        pRes[i] = pRes[0] + nTotal;
        nTotal += Vec_IntSize(vOne) + 1;
        if ( fVerbose )
        printf( "%d : ", i );
        Vec_IntForEachEntry( vOne, Value, k )
        {
            pRes[i][k] = Value;
            if ( fVerbose )
            printf( "%d(%d) ", Value&0xffff, Value>>16 );
        }
        if ( fVerbose )
        printf( "\n" );
        pRes[i][k] = 0;
    }
    assert( nTotal == nEntries );
    return pRes;
}

static Amap_Nod_t* Amap_LibNod ( Amap_Lib_t *  p, int  i  )

inlinestatic

Definition at line 264 of file amapInt.h.

{ return p->pNodes + i;           }

int Amap_LibNumPinsMax

(

Amap_Lib_t *

p

)

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

Synopsis [Returns the largest gate size.]

Description []

SideEffects []

SeeAlso []

Definition at line 103 of file amapLib.c.

{
    Amap_Gat_t * pGate;
    int i, Counter = 0;
    Amap_LibForEachGate( p, pGate, i )
        if ( Counter < (int)pGate->nPins )
            Counter = pGate->nPins;
    return Counter;
}

int Amap_LibParseEquations	(	Amap_Lib_t *	p,
		int	fVerbose
	)

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

Synopsis [Parses equations for the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 392 of file amapParse.c.

{
//    extern int Kit_TruthSupportSize( unsigned * pTruth, int nVars );
    Hop_Man_t * pMan;
    Hop_Obj_t * pObj;
    Vec_Ptr_t * vNames;
    Vec_Int_t * vTruth;
    Amap_Gat_t * pGate;
    Amap_Pin_t * pPin;
    unsigned * pTruth;
    int i, nPinMax;
    nPinMax = Amap_LibNumPinsMax(p);
    if ( nPinMax > AMAP_MAXINS )
        printf( "Gates with more than %d inputs will be ignored.\n", AMAP_MAXINS );
    vTruth = Vec_IntAlloc( 1 << 16 );
    vNames = Vec_PtrAlloc( 100 );
    pMan = Hop_ManStart();
    Hop_IthVar( pMan, nPinMax - 1 );
    Vec_PtrForEachEntry( Amap_Gat_t *, p->vGates, pGate, i )
    {
        if ( pGate->nPins == 0 )
        {
            pGate->pFunc = (unsigned *)Aig_MmFlexEntryFetch( p->pMemGates, 4 );
            if ( strcmp( pGate->pForm, AMAP_STRING_CONST0 ) == 0 )
                pGate->pFunc[0] = 0;
            else if ( strcmp( pGate->pForm, AMAP_STRING_CONST1 ) == 0 )
                pGate->pFunc[0] = ~0;
            else
            {
                printf( "Cannot parse formula \"%s\" of gate \"%s\" with no pins.\n", pGate->pForm, pGate->pName );
                break;
            }
            continue;
        }
        if ( pGate->nPins > AMAP_MAXINS )
            continue;
        Vec_PtrClear( vNames );
        Amap_GateForEachPin( pGate, pPin )
            Vec_PtrPush( vNames, pPin->pName );
        pObj = Amap_ParseFormula( stdout, pGate->pForm, vNames, pMan );
        if ( pObj == NULL )
            break;
        pTruth = Hop_ManConvertAigToTruth( pMan, pObj, pGate->nPins, vTruth, 0 );
        if ( Kit_TruthSupportSize(pTruth, pGate->nPins) < (int)pGate->nPins )
        {
            if ( fVerbose )
                printf( "Skipping gate \"%s\" because its output \"%s\" does not depend on all input variables.\n", pGate->pName, pGate->pForm );
            continue;
        }
        pGate->pFunc = (unsigned *)Aig_MmFlexEntryFetch( p->pMemGates, sizeof(unsigned)*Abc_TruthWordNum(pGate->nPins) );
        memcpy( pGate->pFunc, pTruth, sizeof(unsigned)*Abc_TruthWordNum(pGate->nPins) );
    }
    Vec_PtrFree( vNames );
    Vec_IntFree( vTruth );
    Hop_ManStop( pMan );
    return i == Vec_PtrSize(p->vGates);
}

Amap_Lib_t* Amap_LibReadBuffer	(	char *	pBuffer,
		int	fVerbose
	)

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

Synopsis [Reads the library from the input file.]

Description []

SideEffects []

SeeAlso []

Definition at line 446 of file amapRead.c.

{
    Amap_Lib_t * pLib;
    Vec_Ptr_t * vTokens;
    Amap_RemoveComments( pBuffer, NULL, NULL );
    vTokens = Amap_DeriveTokens( pBuffer );
    pLib = Amap_ParseTokens( vTokens, fVerbose );
    if ( pLib == NULL )
    {
        Vec_PtrFree( vTokens );
        return NULL;
    }
    Vec_PtrFree( vTokens );
    return pLib;
}

Amap_Lib_t* Amap_LibReadFile	(	char *	pFileName,
		int	fVerbose
	)

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

Synopsis [Reads the library from the input file.]

Description []

SideEffects []

SeeAlso []

Definition at line 473 of file amapRead.c.

{
    Amap_Lib_t * pLib;
    char * pBuffer;
    pBuffer = Amap_LoadFile( pFileName );
    if ( pBuffer == NULL )
        return NULL;
    pLib = Amap_LibReadBuffer( pBuffer, fVerbose );
    if ( pLib )
        pLib->pName = Abc_UtilStrsav( pFileName );
    ABC_FREE( pBuffer );
    return pLib;
}

Vec_Ptr_t* Amap_LibSelectGates	(	Amap_Lib_t *	p,
		int	fVerbose
	)

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

Synopsis [Selects gates useful for area-only mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 261 of file amapLib.c.

{
    Vec_Ptr_t * vSelect;
    Amap_Gat_t * pGate, * pGate2;
    int i, k;//, clk = Abc_Clock();
    p->pGate0   = Amap_LibFindGate( p, 0 );
    p->pGate1   = Amap_LibFindGate( p, ~0 );
    p->pGateBuf = Amap_LibFindGate( p, 0xAAAAAAAA );
    p->pGateInv = Amap_LibFindGate( p, ~0xAAAAAAAA );
    vSelect = Vec_PtrAlloc( 100 );
    Vec_PtrForEachEntry( Amap_Gat_t *, p->vSorted, pGate, i )
    {
        if ( pGate->pFunc == NULL || pGate->pTwin != NULL )
            continue;
        Vec_PtrForEachEntryStop( Amap_Gat_t *, p->vSorted, pGate2, k, i )
        {
            if ( pGate2->pFunc == NULL || pGate2->pTwin != NULL )
                continue;
            if ( pGate2->nPins != pGate->nPins )
                continue;
            if ( !memcmp( pGate2->pFunc, pGate->pFunc, sizeof(unsigned) * Abc_TruthWordNum(pGate->nPins) ) )
                break;
        }
        if ( k < i )
            continue;
        Vec_PtrPush( vSelect, pGate );            
    }
    return vSelect;
}

short* Amap_LibTableFindNode	(	Amap_Lib_t *	p,
		int	iFan0,
		int	iFan1,
		int	fXor
	)

void Amap_LibWrite	(	FILE *	pFile,
		Amap_Lib_t *	pLib,
		int	fPrintDsd
	)

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

Synopsis [Writes library.]

Description []

SideEffects []

SeeAlso []

Definition at line 179 of file amapLib.c.

{
    Amap_Gat_t * pGate;
    int i;
    fprintf( pFile, "# The genlib library \"%s\".\n", pLib->pName );
    Amap_LibForEachGate( pLib, pGate, i )
        Amap_LibWriteGate( pFile, pGate, fPrintDsd );
}

static int Amap_ManAndNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 228 of file amapInt.h.

{ return p->nObjs[AMAP_OBJ_AND];                     }

static Amap_Obj_t* Amap_ManConst1 ( Amap_Man_t *  p )

inlinestatic

Definition at line 234 of file amapInt.h.

{ return p->pConst1;                                 }

void Amap_ManCreate	(	Amap_Man_t *	p,
		Aig_Man_t *	pAig
	)

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

Synopsis [Starts the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 323 of file amapGraph.c.

{
    Vec_Ptr_t * vNodes;
    Amap_Obj_t * pChoices[4];
    Aig_Obj_t * pObj, * pFanin, * pPrev, * pFan0, * pFan1, * pFanC;
    int i, fChoices;
    if ( pAig->pEquivs )
        vNodes = Aig_ManDfsChoices( pAig );
    else
        vNodes = Aig_ManDfs( pAig, 1 );
    p->pConst1 = Amap_ManCreateConst1( p );
    // print warning about excessive memory usage
    if ( p->pPars->fVerbose )
    {
        if ( 1.0 * Aig_ManObjNum(pAig) * sizeof(Amap_Obj_t) / (1<<30) > 0.1 )
        printf( "Warning: Mapper allocates %.3f GB for subject graph with %d objects.\n", 
            1.0 * Aig_ManObjNum(pAig) * sizeof(Amap_Obj_t) / (1<<30), Aig_ManObjNum(pAig) );
    }
    // create PIs and remember them in the old nodes
    Aig_ManCleanData(pAig);
    Aig_ManConst1(pAig)->pData = Amap_ManConst1( p );
    Aig_ManForEachCi( pAig, pObj, i )
        pObj->pData = Amap_ManCreatePi( p );
    // load the AIG into the mapper
    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
    {
        fChoices = 0;
        if ( p->fUseXor && Aig_ObjRecognizeExor(pObj, &pFan0, &pFan1 ) )
        {
            Amap_ManCreateXorChoices( p, Amap_AndToObj(pFan0), Amap_AndToObj(pFan1), pChoices );
            fChoices = 1;
        }
        else if ( p->fUseMux && Aig_ObjIsMuxType(pObj) )
        {
            pFanC = Aig_ObjRecognizeMux( pObj, &pFan1, &pFan0 );
            Amap_ManCreateMuxChoices( p, Amap_AndToObj(pFan0), Amap_AndToObj(pFan1), Amap_AndToObj(pFanC), pChoices );
            fChoices = 1;
        }
        pObj->pData = Amap_ManCreateAnd( p, (Amap_Obj_t *)Aig_ObjChild0Copy(pObj), (Amap_Obj_t *)Aig_ObjChild1Copy(pObj) );
        if ( fChoices )
        {
            p->nChoicesAdded++;
            Amap_ObjSetChoice( (Amap_Obj_t *)pObj->pData, pChoices[0] );
            Amap_ObjSetChoice( pChoices[0], pChoices[1] );
            Amap_ObjSetChoice( pChoices[1], pChoices[2] );
            Amap_ObjSetChoice( pChoices[2], pChoices[3] );
            Amap_ManCreateChoice( p, (Amap_Obj_t *)pObj->pData );
        }
        if ( Aig_ObjIsChoice( pAig, pObj ) )
        {
//            assert( !fChoices );
            p->nChoicesGiven++;
            for ( pPrev = pObj, pFanin = Aig_ObjEquiv(pAig, pObj); pFanin; pPrev = pFanin, pFanin = Aig_ObjEquiv(pAig, pFanin) )
            {
                ((Amap_Obj_t *)pFanin->pData)->fRepr = 0;
                Amap_ObjSetChoice( Amap_ManGetLast_rec(p, (Amap_Obj_t *)pPrev->pData), 
                    (Amap_Obj_t *)pFanin->pData );
            }
            Amap_ManCreateChoice( p, (Amap_Obj_t *)pObj->pData );
        }
    }
    Vec_PtrFree( vNodes );
    // set the primary outputs without copying the phase
    Aig_ManForEachCo( pAig, pObj, i )
        pObj->pData = Amap_ManCreatePo( p, (Amap_Obj_t *)Aig_ObjChild0Copy(pObj) );
    if ( p->pPars->fVerbose )
        printf( "Performing mapping with %d given and %d created choices.\n", 
            p->nChoicesGiven, p->nChoicesAdded );
}

Amap_Obj_t* Amap_ManCreateAnd	(	Amap_Man_t *	p,
		Amap_Obj_t *	pFan0,
		Amap_Obj_t *	pFan1
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 137 of file amapGraph.c.

{
    Amap_Obj_t * pObj;
    pObj = Amap_ManSetupObj( p );
    pObj->Type   = AMAP_OBJ_AND;
    pObj->Fan[0] = Amap_ObjToLit(pFan0);  Amap_Regular(pFan0)->nRefs++;
    pObj->Fan[1] = Amap_ObjToLit(pFan1);  Amap_Regular(pFan1)->nRefs++;
    assert( Abc_Lit2Var(pObj->Fan[0]) != Abc_Lit2Var(pObj->Fan[1]) );
    pObj->fPhase = Amap_ObjPhaseReal(pFan0) & Amap_ObjPhaseReal(pFan1);
    pObj->Level  = 1 + Abc_MaxInt( Amap_Regular(pFan0)->Level, Amap_Regular(pFan1)->Level );
    if ( p->nLevelMax < (int)pObj->Level )
        p->nLevelMax = (int)pObj->Level;
    assert( p->nLevelMax < 4094 ); // 2^12-2
    p->nObjs[AMAP_OBJ_AND]++;
    return pObj;
}

void Amap_ManCreateChoice	(	Amap_Man_t *	p,
		Amap_Obj_t *	pObj
	)

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

Synopsis [Creates the choice node.]

Description [Should be called after the equivalence class nodes are linked.]

SideEffects []

SeeAlso []

Definition at line 222 of file amapGraph.c.

{
    Amap_Obj_t * pTemp;
    // mark the node as a representative if its class
//    assert( pObj->fRepr == 0 );
    pObj->fRepr = 1;
    // update the level of this node (needed for correct required time computation)
    for ( pTemp = pObj; pTemp; pTemp = Amap_ObjChoice(p, pTemp) )
    {
        pObj->Level = Abc_MaxInt( pObj->Level, pTemp->Level );
//        pTemp->nVisits++; pTemp->nVisitsCopy++;
    }
    // mark the largest level
    if ( p->nLevelMax < (int)pObj->Level )
        p->nLevelMax = (int)pObj->Level;
    assert( p->nLevelMax < 4094 ); // 2^12-2
}

Amap_Obj_t* Amap_ManCreateMux	(	Amap_Man_t *	p,
		Amap_Obj_t *	pFan0,
		Amap_Obj_t *	pFan1,
		Amap_Obj_t *	pFanC
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file amapGraph.c.

{
    Amap_Obj_t * pObj;
    pObj = Amap_ManSetupObj( p );
    pObj->Type   = AMAP_OBJ_MUX;
    pObj->Fan[0] = Amap_ObjToLit(pFan0);  Amap_Regular(pFan0)->nRefs++;
    pObj->Fan[1] = Amap_ObjToLit(pFan1);  Amap_Regular(pFan1)->nRefs++;
    pObj->Fan[2] = Amap_ObjToLit(pFanC);  Amap_Regular(pFanC)->nRefs++;
    pObj->fPhase = (Amap_ObjPhaseReal(pFan1) &  Amap_ObjPhaseReal(pFanC)) | 
                   (Amap_ObjPhaseReal(pFan0) & ~Amap_ObjPhaseReal(pFanC));
    pObj->Level  = Abc_MaxInt( Amap_Regular(pFan0)->Level, Amap_Regular(pFan1)->Level );
    pObj->Level  = 2 + Abc_MaxInt( pObj->Level, Amap_Regular(pFanC)->Level );
    if ( p->nLevelMax < (int)pObj->Level )
        p->nLevelMax = (int)pObj->Level;
    assert( p->nLevelMax < 4094 ); // 2^12-2
    p->nObjs[AMAP_OBJ_MUX]++;
    return pObj;
}

Amap_Obj_t* Amap_ManCreatePi

(

Amap_Man_t *

p

)

FUNCTION DECLARATIONS ///.

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

Synopsis [Creates primary input.]

Description []

SideEffects []

SeeAlso []

Definition at line 88 of file amapGraph.c.

{
    Amap_Obj_t * pObj;
    pObj = Amap_ManSetupObj( p );
    pObj->Type  = AMAP_OBJ_PI;
    pObj->IdPio = Vec_PtrSize( p->vPis );
    Vec_PtrPush( p->vPis, pObj );
    p->nObjs[AMAP_OBJ_PI]++;
    return pObj;
}

Amap_Obj_t* Amap_ManCreatePo	(	Amap_Man_t *	p,
		Amap_Obj_t *	pFan0
	)

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

Synopsis [Creates primary output with the given driver.]

Description []

SideEffects []

SeeAlso []

Definition at line 110 of file amapGraph.c.

{
    Amap_Obj_t * pObj;
    pObj = Amap_ManSetupObj( p );
    pObj->IdPio  = Vec_PtrSize( p->vPos );
    Vec_PtrPush( p->vPos, pObj );
    pObj->Type   = AMAP_OBJ_PO;
    pObj->Fan[0] = Amap_ObjToLit(pFan0);  Amap_Regular(pFan0)->nRefs++;
    pObj->Level  = Amap_Regular(pFan0)->Level;
    if ( p->nLevelMax < (int)pObj->Level )
        p->nLevelMax = (int)pObj->Level;
    assert( p->nLevelMax < 4094 ); // 2^12-2
    p->nObjs[AMAP_OBJ_PO]++;
    return pObj;
}

Amap_Obj_t* Amap_ManCreateXor	(	Amap_Man_t *	p,
		Amap_Obj_t *	pFan0,
		Amap_Obj_t *	pFan1
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 165 of file amapGraph.c.

{
    Amap_Obj_t * pObj;
    pObj = Amap_ManSetupObj( p );
    pObj->Type   = AMAP_OBJ_XOR;
    pObj->Fan[0] = Amap_ObjToLit(pFan0);  Amap_Regular(pFan0)->nRefs++;
    pObj->Fan[1] = Amap_ObjToLit(pFan1);  Amap_Regular(pFan1)->nRefs++;
    pObj->fPhase = Amap_ObjPhaseReal(pFan0) ^ Amap_ObjPhaseReal(pFan1);
    pObj->Level  = 2 + Abc_MaxInt( Amap_Regular(pFan0)->Level, Amap_Regular(pFan1)->Level );
    if ( p->nLevelMax < (int)pObj->Level )
        p->nLevelMax = (int)pObj->Level;
    assert( p->nLevelMax < 4094 ); // 2^12-2
    p->nObjs[AMAP_OBJ_XOR]++;
    return pObj;
}

static Amap_Cut_t* Amap_ManCutNext ( Amap_Cut_t *  pCut )

inlinestatic

Definition at line 267 of file amapInt.h.

{ return (Amap_Cut_t *)(((int *)pCut)+pCut->nFans+1); }

static Amap_Cut_t** Amap_ManCutNextP ( Amap_Cut_t *  pCut )

inlinestatic

Definition at line 270 of file amapInt.h.

{ return (Amap_Cut_t **)(((int *)pCut)+pCut->nFans+1); }

void Amap_ManMap

(

Amap_Man_t *

p

)

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

Synopsis [Performs mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 593 of file amapMatch.c.

{
    int i;
    Amap_ManMerge( p );
    for ( i = 0; i < p->pPars->nIterFlow; i++ )
        Amap_ManMatch( p, 1, i>0 );
    for ( i = 0; i < p->pPars->nIterArea; i++ )
        Amap_ManMatch( p, 0, p->pPars->nIterFlow>0||i>0 );
/*
    for ( i = 0; i < p->pPars->nIterFlow; i++ )
        Amap_ManMatch( p, 1, 1 );
    for ( i = 0; i < p->pPars->nIterArea; i++ )
        Amap_ManMatch( p, 0, 1 );
*/
    Amap_ManCleanData( p );
}

void Amap_ManMerge

(

Amap_Man_t *

p

)

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

Synopsis [Derives cuts for all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 514 of file amapMerge.c.

{
    Amap_Obj_t * pObj;
    int i;
    abctime clk = Abc_Clock();
    p->pCutsPi = Amap_ManSetupPis( p );
    Amap_ManForEachNode( p, pObj, i )
        Amap_ManMergeNodeCuts( p, pObj );
    if ( p->pPars->fVerbose )
    {
        printf( "AIG object is %d bytes.  ", (int)sizeof(Amap_Obj_t) );
        printf( "Internal AIG = %5.2f MB.  Cuts = %5.2f MB.  CutsMax = %d.\n", 
            1.0*Amap_ManObjNum(p)*sizeof(Amap_Obj_t)/(1<<20), 1.0*p->nBytesUsed/(1<<20), p->pPars->nCutsMax );
        printf( "Node =%6d. Try =%9d. Try3 =%10d. Used =%7d. R =%6.2f.  ", 
            Amap_ManNodeNum(p), p->nCutsTried, p->nCutsTried3, p->nCutsUsed, 
            1.0*p->nCutsUsed/Amap_ManNodeNum(p) );
ABC_PRT( "Time ", Abc_Clock() - clk );
    }
}

static int Amap_ManMuxNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 230 of file amapInt.h.

{ return p->nObjs[AMAP_OBJ_MUX];                     }

static int Amap_ManNodeNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 232 of file amapInt.h.

{ return p->nObjs[AMAP_OBJ_AND] + p->nObjs[AMAP_OBJ_XOR] + p->nObjs[AMAP_OBJ_MUX];   }

static Amap_Obj_t* Amap_ManObj ( Amap_Man_t *  p, int  i  )

inlinestatic

Definition at line 237 of file amapInt.h.

{ return (Amap_Obj_t *)Vec_PtrEntry( p->vObjs, i );  }

static int Amap_ManObjNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 231 of file amapInt.h.

{ return Vec_PtrSize(p->vObjs);                      }

static Amap_Obj_t* Amap_ManPi ( Amap_Man_t *  p, int  i  )

inlinestatic

Definition at line 235 of file amapInt.h.

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

static int Amap_ManPiNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 226 of file amapInt.h.

{ return p->nObjs[AMAP_OBJ_PI];                      }

static Amap_Obj_t* Amap_ManPo ( Amap_Man_t *  p, int  i  )

inlinestatic

Definition at line 236 of file amapInt.h.

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

static int Amap_ManPoNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 227 of file amapInt.h.

{ return p->nObjs[AMAP_OBJ_PO];                      }

Vec_Ptr_t* Amap_ManProduceMapped

(

Amap_Man_t *

p

)

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

Synopsis [Returns mapped network as an array of structures.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file amapOutput.c.

{
    Vec_Ptr_t * vNodes;
    Aig_MmFlex_t * pMem;
    Amap_Obj_t * pObj, * pFanin;
    Amap_Gat_t * pGate;
    Amap_Out_t * pRes;
    int i, k, iFanin, fCompl;
    float TotalArea = 0.0;
    pMem = Aig_MmFlexStart();
    // create mapping object for each node used in the mapping
    vNodes = Vec_PtrAlloc( 10 );
    Amap_ManForEachObj( p, pObj, i )
    {
        if ( Amap_ObjIsPi(pObj) )
        {
            assert( pObj->fPolar == 0 );
            pRes = Amap_OutputStructAlloc( pMem, NULL );
            pRes->Type  = -1;
            pRes->nFans = 0;
            // save this structure
            pObj->iData = Vec_PtrSize( vNodes );
            Vec_PtrPush( vNodes, pRes );
            // create invertor if needed
            if ( pObj->nFouts[1] ) // this PI is used in the neg polarity
            {
                pRes = Amap_OutputStructAlloc( pMem, p->pLib->pGateInv );
                pRes->pFans[0] = pObj->iData;
                // save this structure
                Vec_PtrPush( vNodes, pRes );
                TotalArea += p->pLib->pGateInv->dArea;
            }
            continue;
        }
        if ( Amap_ObjIsNode(pObj) )
        {
            // skip the node that is not used in the mapping
            if ( Amap_ObjRefsTotal(pObj) == 0 )
                continue;
            // get the gate
            pGate = Amap_LibGate( p->pLib, pObj->Best.pSet->iGate );
            assert( pGate->nPins == pObj->Best.pCut->nFans );
            // allocate structure
            pRes = Amap_OutputStructAlloc( pMem, pGate );
            Amap_MatchForEachFaninCompl( p, &pObj->Best, pFanin, fCompl, k )
            {
                assert( Amap_ObjRefsTotal(pFanin) );
                if ( (int)pFanin->fPolar == fCompl )
                    pRes->pFans[k] = pFanin->iData;
                else
                    pRes->pFans[k] = pFanin->iData + 1;
            }
            // save this structure
            pObj->iData = Vec_PtrSize( vNodes );
            Vec_PtrPush( vNodes, pRes );
            TotalArea += pGate->dArea;
            // create invertor if needed
            if ( pObj->nFouts[!pObj->fPolar] ) // needed in the opposite polarity
            {
                pRes = Amap_OutputStructAlloc( pMem, p->pLib->pGateInv );
                pRes->pFans[0] = pObj->iData;
                // save this structure
                Vec_PtrPush( vNodes, pRes );
                TotalArea += p->pLib->pGateInv->dArea;
            }
            continue;
        }
        if ( Amap_ObjIsPo(pObj) )
        {
            assert( pObj->fPolar == 0 );
            pFanin = Amap_ObjFanin0(p, pObj);
            assert( Amap_ObjRefsTotal(pFanin) );
            if ( Amap_ObjIsConst1(pFanin)  )
            { // create constant node
                if ( Amap_ObjFaninC0(pObj) )
                {
                    pRes = Amap_OutputStructAlloc( pMem, p->pLib->pGate0 );
                    TotalArea += p->pLib->pGate0->dArea;
                }
                else
                {
                    pRes = Amap_OutputStructAlloc( pMem, p->pLib->pGate1 );
                    TotalArea += p->pLib->pGate1->dArea;
                }
                // save this structure
                iFanin = Vec_PtrSize( vNodes );
                Vec_PtrPush( vNodes, pRes );
            }
            else 
            {
                if ( (int)pFanin->fPolar == Amap_ObjFaninC0(pObj) )
                    iFanin = pFanin->iData;
                else
                    iFanin = pFanin->iData + 1;
            }
            // create PO node
            pRes = Amap_OutputStructAlloc( pMem, NULL );
            pRes->Type     = 1;
            pRes->pFans[0] = iFanin;
            // save this structure
            Vec_PtrPush( vNodes, pRes );
        }
    }
    // return memory manager in the last entry of the array
    Vec_PtrPush( vNodes, pMem );
    return vNodes;
}

Amap_Man_t* Amap_ManStart

(

int

nNodes

)

DECLARATIONS ///.

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

FileName [amapMan.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Technology mapper for standard cells.]

Synopsis [Mapping manager.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:

amapMan.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

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

Synopsis [Starts the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file amapMan.c.

{
    Amap_Man_t * p;
    // start the manager
    p = ABC_ALLOC( Amap_Man_t, 1 );
    memset( p, 0, sizeof(Amap_Man_t) );
    p->fEpsilonInternal = (float)0.01;
    // allocate arrays for nodes
    p->vPis    = Vec_PtrAlloc( 100 );
    p->vPos    = Vec_PtrAlloc( 100 );
    p->vObjs   = Vec_PtrAlloc( 100 );
    p->vTemp   = Vec_IntAlloc( 100 );
    p->vCuts0  = Vec_PtrAlloc( 100 );
    p->vCuts1  = Vec_PtrAlloc( 100 );
    p->vCuts2  = Vec_PtrAlloc( 100 );
    // prepare the memory manager
    p->pMemObj = Aig_MmFixedStart( sizeof(Amap_Obj_t), nNodes );
    p->pMemCuts = Aig_MmFlexStart();
    p->pMemCutBest = Aig_MmFlexStart();
    p->pMemTemp = Aig_MmFlexStart();
    return p;
}

void Amap_ManStop

(

Amap_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 79 of file amapMan.c.

{
    Vec_PtrFree( p->vPis );
    Vec_PtrFree( p->vPos );
    Vec_PtrFree( p->vObjs );
    Vec_PtrFree( p->vCuts0 );
    Vec_PtrFree( p->vCuts1 );
    Vec_PtrFree( p->vCuts2 );
    Vec_IntFree( p->vTemp );
    Aig_MmFixedStop( p->pMemObj, 0 );
    Aig_MmFlexStop( p->pMemCuts, 0 );
    Aig_MmFlexStop( p->pMemCutBest, 0 );
    Aig_MmFlexStop( p->pMemTemp, 0 );
    ABC_FREE( p->pMatsTemp );
    ABC_FREE( p->ppCutsTemp );
    ABC_FREE( p->pCutsPi );
    ABC_FREE( p );
}

static int Amap_ManXorNum ( Amap_Man_t *  p )

inlinestatic

Definition at line 229 of file amapInt.h.

{ return p->nObjs[AMAP_OBJ_XOR];                     }

static Amap_Obj_t* Amap_Not ( Amap_Obj_t *  p )

inlinestatic

Definition at line 222 of file amapInt.h.

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

static Amap_Obj_t* Amap_NotCond ( Amap_Obj_t *  p, int  c  )

inlinestatic

Definition at line 223 of file amapInt.h.

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

static Amap_Obj_t* Amap_ObjChoice ( Amap_Man_t *  p, Amap_Obj_t *  pObj  )

inlinestatic

Definition at line 258 of file amapInt.h.

{ return pObj->Equiv? Amap_ManObj(p, pObj->Equiv) : NULL; }

static void* Amap_ObjCopy ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 254 of file amapInt.h.

{ return pObj->pData;                                }

static Amap_Obj_t* Amap_ObjFanin0 ( Amap_Man_t *  p, Amap_Obj_t *  pObj  )

inlinestatic

Definition at line 248 of file amapInt.h.

{ return Amap_ManObj(p, Abc_Lit2Var(pObj->Fan[0])); }

static Amap_Obj_t* Amap_ObjFanin1 ( Amap_Man_t *  p, Amap_Obj_t *  pObj  )

inlinestatic

Definition at line 249 of file amapInt.h.

{ return Amap_ManObj(p, Abc_Lit2Var(pObj->Fan[1])); }

static Amap_Obj_t* Amap_ObjFanin2 ( Amap_Man_t *  p, Amap_Obj_t *  pObj  )

inlinestatic

Definition at line 250 of file amapInt.h.

{ return Amap_ManObj(p, Abc_Lit2Var(pObj->Fan[2])); }

static int Amap_ObjFaninC0 ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 251 of file amapInt.h.

{ return Abc_LitIsCompl(pObj->Fan[0]);              }

static int Amap_ObjFaninC1 ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 252 of file amapInt.h.

{ return Abc_LitIsCompl(pObj->Fan[1]);              }

static int Amap_ObjFaninC2 ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 253 of file amapInt.h.

{ return Abc_LitIsCompl(pObj->Fan[2]);              }

static int Amap_ObjIsAnd ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 242 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_AND;                 }

static int Amap_ObjIsConst1 ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 239 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_CONST1;              }

static int Amap_ObjIsMux ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 244 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_MUX;                 }

static int Amap_ObjIsNode ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 245 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_AND || pObj->Type == AMAP_OBJ_XOR || pObj->Type == AMAP_OBJ_MUX;  }

static int Amap_ObjIsPi ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 240 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_PI;                  }

static int Amap_ObjIsPo ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 241 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_PO;                  }

static int Amap_ObjIsXor ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 243 of file amapInt.h.

{ return pObj->Type == AMAP_OBJ_XOR;                 }

static int Amap_ObjLevel ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 255 of file amapInt.h.

{ return pObj->Level;                                }

static int Amap_ObjPhaseReal ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 260 of file amapInt.h.

{ return Amap_Regular(pObj)->fPhase ^ Amap_IsComplement(pObj);   }

static int Amap_ObjRefsTotal ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 261 of file amapInt.h.

{ return pObj->nFouts[0] + pObj->nFouts[1];          }

static void Amap_ObjSetChoice ( Amap_Obj_t *  pObj, Amap_Obj_t *  pEqu  )

inlinestatic

Definition at line 259 of file amapInt.h.

{ assert(pObj->Equiv==0); pObj->Equiv = pEqu->Id;                            }

static void Amap_ObjSetCopy ( Amap_Obj_t *  pObj, void *  pCopy  )

inlinestatic

Definition at line 257 of file amapInt.h.

{ pObj->pData = pCopy;                               }

static void Amap_ObjSetLevel ( Amap_Obj_t *  pObj, int  Level  )

inlinestatic

Definition at line 256 of file amapInt.h.

{ pObj->Level = Level;                               }

static int Amap_ObjToLit ( Amap_Obj_t *  pObj )

inlinestatic

Definition at line 247 of file amapInt.h.

{ return Abc_Var2Lit( Amap_Regular(pObj)->Id, Amap_IsComplement(pObj) ); }

static Amap_Obj_t* Amap_Regular ( Amap_Obj_t *  p )

inlinestatic

Definition at line 221 of file amapInt.h.

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

void Kit_DsdPrintFromTruth	(	unsigned *	pTruth,
		int	nVars
	)

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

Synopsis [Print the DSD formula.]

Description []

SideEffects []

SeeAlso []

Definition at line 490 of file kitDsd.c.

{
    Kit_DsdNtk_t * pTemp, * pTemp2;
//    pTemp = Kit_DsdDecomposeMux( pTruth, nVars, 5 );
    pTemp = Kit_DsdDecomposeMux( pTruth, nVars, 8 );
//    Kit_DsdPrintExpanded( pTemp );
    pTemp2 = Kit_DsdExpand( pTemp );
    Kit_DsdPrint( stdout, pTemp2 );
    Kit_DsdVerify( pTemp2, pTruth, nVars ); 
    Kit_DsdNtkFree( pTemp2 );
    Kit_DsdNtkFree( pTemp );
}