mpmInt.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "misc/mem/mem2.h"
#include "misc/vec/vec.h"
#include "misc/vec/vecMem.h"
#include "misc/vec/vecHsh.h"
#include "misc/vec/vecWec.h"
#include "misc/util/utilTruth.h"
#include "mpmMig.h"
#include "mpm.h"

Go to the source code of this file.

Data Structures
struct	Mpm_Cut_t_
struct	Mpm_Uni_t_
struct	Mpm_Dsd_t_
struct	Mpm_Man_t_

Macros
#define	MPM_CUT_MAX   32
	INCLUDES ///. More...
#define	MPM_UNIT_TIME   1
#define	MPM_UNIT_AREA   20
#define	MPM_UNIT_EDGE   50
#define	MPM_UNIT_REFS   100
#define	Mpm_ObjForEachCut(p, pObj, hCut, pCut)   for ( hCut = Mpm_ObjCutList(p, pObj); hCut && (pCut = Mpm_CutFetch(p, hCut)); hCut = pCut->hNext )
#define	Mpm_ObjForEachCutSafe(p, pObj, hCut, pCut, hNext)   for ( hCut = Mpm_ObjCutList(p, pObj); hCut && (pCut = Mpm_CutFetch(p, hCut)) && ((hNext = pCut->hNext), 1); hCut = hNext )
#define	Mpm_CutForEachLeafId(pCut, iLeafId, i)   for ( i = 0; i < (int)pCut->nLeaves && ((iLeafId = Abc_Lit2Var(pCut->pLeaves[i])), 1); i++ )
#define	Mpm_CutForEachLeafLit(pCut, iLeafLit, i)   for ( i = 0; i < (int)pCut->nLeaves && ((iLeafLit = pCut->pLeaves[i]), 1); i++ )
#define	Mpm_CutForEachLeaf(p, pCut, pLeaf, i)   for ( i = 0; i < (int)pCut->nLeaves && (pLeaf = Mig_ManObj(p, Abc_Lit2Var(pCut->pLeaves[i]))); i++ )

Typedefs
typedef struct Mpm_Cut_t_	Mpm_Cut_t
	BASIC TYPES ///. More...
typedef struct Mpm_Uni_t_	Mpm_Uni_t
typedef struct Mpm_Dsd_t_	Mpm_Dsd_t
typedef struct Mpm_Man_t_	Mpm_Man_t

Functions
static int	Mpm_ObjCutBest (Mpm_Man_t *p, Mig_Obj_t *pObj)
	MACRO DEFINITIONS ///. More...
static void	Mpm_ObjSetCutBest (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static int	Mpm_CutWordNum (int nLeaves)
static Mpm_Cut_t *	Mpm_CutFetch (Mpm_Man_t *p, int h)
static Mpm_Cut_t *	Mpm_ObjCutBestP (Mpm_Man_t *p, Mig_Obj_t *pObj)
static int	Mpm_ObjCutList (Mpm_Man_t *p, Mig_Obj_t *pObj)
static int *	Mpm_ObjCutListP (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetCutList (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static int	Mpm_CutLeafNum (Mpm_Cut_t *pCut)
static word *	Mpm_CutTruth (Mpm_Man_t *p, int iFunc)
static int	Mig_ObjMigRefNum (Mpm_Man_t *p, Mig_Obj_t *pObj)
static int	Mig_ObjMigRefDec (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ManCleanMapRefs (Mpm_Man_t *p)
static int	Mpm_ObjMapRef (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetMapRef (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static int	Mpm_ObjEstRef (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetEstRef (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static void	Mpm_ManCleanRequired (Mpm_Man_t *p)
static int	Mpm_ObjRequired (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetRequired (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static int	Mpm_ObjTime (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetTime (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static int	Mpm_ObjArea (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetArea (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static int	Mpm_ObjEdge (Mpm_Man_t *p, Mig_Obj_t *pObj)
static void	Mpm_ObjSetEdge (Mpm_Man_t *p, Mig_Obj_t *pObj, int i)
static void	Mpm_VarsClear (int *V2P, int *P2V, int nVars)
static void	Mpm_VarsSwap (int *V2P, int *P2V, int iVar, int jVar)
Mig_Man_t *	Mig_ManCreate (void *pGia)
	FUNCTION DECLARATIONS ///. More...
void *	Mpm_ManFromIfLogic (Mpm_Man_t *pMan)
Mpm_Man_t *	Mpm_ManStart (Mig_Man_t *pMig, Mpm_Par_t *pPars)
	DECLARATIONS ///. More...
void	Mpm_ManStop (Mpm_Man_t *p)
void	Mpm_ManPrintStatsInit (Mpm_Man_t *p)
void	Mpm_ManPrintStats (Mpm_Man_t *p)
void	Mpm_ManPrintDsdStats (Mpm_Man_t *p)
void	Mpm_ManPrintPerm (unsigned s)
void	Mpm_ManPrecomputePerms (Mpm_Man_t *p)
word	Mpm_CutTruthFromDsd (Mpm_Man_t *pMan, Mpm_Cut_t *pCut, int iDsdLit)
int	Mpm_CutCheckDsd6 (Mpm_Man_t *p, word t)
int	Mpm_CutComputeDsd6 (Mpm_Man_t *p, Mpm_Cut_t *pCut, Mpm_Cut_t *pCut0, Mpm_Cut_t *pCut1, Mpm_Cut_t *pCutC, int fCompl0, int fCompl1, int fComplC, int Type)
Vec_Wec_t *	Mpm_ManFindDsdMatches (Mpm_Man_t *p, void *pScl)
	DECLARATIONS ///. More...
Mpm_LibLut_t *	Mpm_LibLutSetSimple (int nLutSize)
	DECLARATIONS ///. More...
void	Mpm_LibLutFree (Mpm_LibLut_t *pLib)
void	Mpm_CutPrint (Mpm_Cut_t *pCut)
void	Mpm_ManPrepare (Mpm_Man_t *p)
void	Mpm_ManPerform (Mpm_Man_t *p)
int	Mpm_CutComputeTruth (Mpm_Man_t *p, Mpm_Cut_t *pCut, Mpm_Cut_t *pCut0, Mpm_Cut_t *pCut1, Mpm_Cut_t *pCutC, int fCompl0, int fCompl1, int fComplC, int Type)
void	Kit_DsdPrintFromTruth (unsigned *pTruth, int nVars)

Macro Definition Documentation

#define MPM_CUT_MAX   32

INCLUDES ///.

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

FileName [mpmInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Configurable technology mapper.]

Synopsis [Interal declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 1, 2013.]

Revision [

Id:

mpmInt.h,v 1.00 2013/06/01 00:00:00 alanmi Exp

]PARAMETERS ///

Definition at line 50 of file mpmInt.h.

#define Mpm_CutForEachLeaf	(		p,
			pCut,
			pLeaf,
			i
	)		for ( i = 0; i < (int)pCut->nLeaves && (pLeaf = Mig_ManObj(p, Abc_Lit2Var(pCut->pLeaves[i]))); i++ )

Definition at line 222 of file mpmInt.h.

#define Mpm_CutForEachLeafId	(		pCut,
			iLeafId,
			i
	)		for ( i = 0; i < (int)pCut->nLeaves && ((iLeafId = Abc_Lit2Var(pCut->pLeaves[i])), 1); i++ )

Definition at line 218 of file mpmInt.h.

#define Mpm_CutForEachLeafLit	(		pCut,
			iLeafLit,
			i
	)		for ( i = 0; i < (int)pCut->nLeaves && ((iLeafLit = pCut->pLeaves[i]), 1); i++ )

Definition at line 220 of file mpmInt.h.

#define Mpm_ObjForEachCut	(		p,
			pObj,
			hCut,
			pCut
	)		for ( hCut = Mpm_ObjCutList(p, pObj); hCut && (pCut = Mpm_CutFetch(p, hCut)); hCut = pCut->hNext )

Definition at line 212 of file mpmInt.h.

#define Mpm_ObjForEachCutSafe	(		p,
			pObj,
			hCut,
			pCut,
			hNext
	)		for ( hCut = Mpm_ObjCutList(p, pObj); hCut && (pCut = Mpm_CutFetch(p, hCut)) && ((hNext = pCut->hNext), 1); hCut = hNext )

Definition at line 214 of file mpmInt.h.

#define MPM_UNIT_AREA   20

Definition at line 53 of file mpmInt.h.

#define MPM_UNIT_EDGE   50

Definition at line 54 of file mpmInt.h.

#define MPM_UNIT_REFS   100

Definition at line 55 of file mpmInt.h.

#define MPM_UNIT_TIME   1

Definition at line 52 of file mpmInt.h.

Typedef Documentation

typedef struct Mpm_Cut_t_ Mpm_Cut_t

BASIC TYPES ///.

Definition at line 61 of file mpmInt.h.

typedef struct Mpm_Dsd_t_ Mpm_Dsd_t

Definition at line 84 of file mpmInt.h.

typedef struct Mpm_Man_t_ Mpm_Man_t

Definition at line 94 of file mpmInt.h.

typedef struct Mpm_Uni_t_ Mpm_Uni_t

Definition at line 71 of file mpmInt.h.

Function Documentation

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 );
}

Mig_Man_t* Mig_ManCreate

(

void *

pGia

)

FUNCTION DECLARATIONS ///.

Definition at line 83 of file mpmAbc.c.

{
    Gia_Man_t * p = (Gia_Man_t *)pGia;
    Mig_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Mig_ManStart();
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsMuxId(p, i) )
            pObj->Value = Mig_ManAppendMux( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin2Copy(p, pObj) );
        else if ( Gia_ObjIsXor(pObj) )
            pObj->Value = Mig_ManAppendXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Mig_ManAppendAnd( pNew, Mig_ObjFanin0Copy(pObj), Mig_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Mig_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Mig_ManAppendCo( pNew, Mig_ObjFanin0Copy(pObj) );
        else assert( 0 );
    }
    Mig_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    if ( Gia_ManHasChoices(p) )
        Mig_ManCreateChoices( pNew, p );
    return pNew;
}

static int Mig_ObjMigRefDec ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 186 of file mpmInt.h.

{ return Vec_IntAddToEntry(&p->vMigRefs, Mig_ObjId(pObj), -1);    }

static int Mig_ObjMigRefNum ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 185 of file mpmInt.h.

{ return Vec_IntEntry(&p->vMigRefs, Mig_ObjId(pObj));             }

int Mpm_CutCheckDsd6	(	Mpm_Man_t *	p,
		word	t
	)

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

Synopsis [Checks hash table for DSD class.]

Description []

SideEffects []

SeeAlso []

Definition at line 905 of file mpmDsd.c.

{
    int fCompl, Entry, Config;
    if ( (fCompl = (t & 1)) )
        t = ~t;
    Entry = *Hsh_IntManLookup( p->pHash, (unsigned *)&t );
    if ( Entry == -1 )
        return -1;
    Config = Vec_IntEntry( p->vConfgRes, Entry );
    if ( fCompl )
        Config ^= (1 << 16);
    return Config;
}

int Mpm_CutComputeDsd6	(	Mpm_Man_t *	p,
		Mpm_Cut_t *	pCut,
		Mpm_Cut_t *	pCut0,
		Mpm_Cut_t *	pCut1,
		Mpm_Cut_t *	pCutC,
		int	fCompl0,
		int	fCompl1,
		int	fComplC,
		int	Type
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 930 of file mpmDsd.c.

{
    int fVerbose = 0;
    int i, Config, iClass, fCompl;
    int pLeavesNew[6] = { -1, -1, -1, -1, -1, -1 };
    word t = 0;
    if ( pCutC == NULL )
    {
        word t0, t1;
        int iClass0  = Abc_Lit2Var(pCut0->iFunc);
        int iClass1  = Abc_Lit2Var(pCut1->iFunc);
        word Truth0  = p->pDsd6[iClass0].uTruth;
        int Perm1    = Vec_IntEntry( p->vMap2Perm, p->uPermMask[1] );
        word Truth1p = Vec_WrdEntry( p->vPerm6, iClass1 * 720 + Perm1 );
        if ( p->uComplMask[1] )
        {
            for ( i = 0; i < 6; i++ )
                if ( (p->uComplMask[1] >> i) & 1 )
                    Truth1p = Abc_Tt6Flip( Truth1p, i );            
        }
        t0 = (fCompl0 ^ pCut0->fCompl ^ Abc_LitIsCompl(pCut0->iFunc)) ? ~Truth0  : Truth0;
        t1 = (fCompl1 ^ pCut1->fCompl ^ Abc_LitIsCompl(pCut1->iFunc)) ? ~Truth1p : Truth1p;
        if ( Type == 1 )
            t = t0 & t1;
        else if ( Type == 2 )
            t = t0 ^ t1;
        else assert( 0 );

if ( fVerbose )
{
Mpm_ManPrintPerm( p->uPermMask[1] );               printf( "\n" );
Kit_DsdPrintFromTruth( (unsigned *)&Truth0, 6 );   printf( "\n" );
Kit_DsdPrintFromTruth( (unsigned *)&Truth1p, 6 );  printf( "\n" );
Kit_DsdPrintFromTruth( (unsigned *)&t, 6 );        printf( "\n" );
}
    }
    else
    {
        word t0, t1, tC;
        int iClass0  = Abc_Lit2Var(pCut0->iFunc);
        int iClass1  = Abc_Lit2Var(pCut1->iFunc);
        int iClassC  = Abc_Lit2Var(pCutC->iFunc);
        word Truth0  = p->pDsd6[iClass0].uTruth;
        int Perm1    = Vec_IntEntry( p->vMap2Perm, p->uPermMask[1] );
        int PermC    = Vec_IntEntry( p->vMap2Perm, p->uPermMask[2] );
        word Truth1p = Vec_WrdEntry( p->vPerm6, iClass1 * 720 + Perm1 );
        word TruthCp = Vec_WrdEntry( p->vPerm6, iClassC * 720 + PermC );
        if ( p->uComplMask[1] )
        {
            for ( i = 0; i < 6; i++ )
                if ( (p->uComplMask[1] >> i) & 1 )
                    Truth1p = Abc_Tt6Flip( Truth1p, i );            
        }
        if ( p->uComplMask[2] )
        {
            for ( i = 0; i < 6; i++ )
                if ( (p->uComplMask[2] >> i) & 1 )
                    TruthCp = Abc_Tt6Flip( TruthCp, i );            
        }
        t0 = (fCompl0 ^ pCut0->fCompl ^ Abc_LitIsCompl(pCut0->iFunc)) ? ~Truth0  : Truth0;
        t1 = (fCompl1 ^ pCut1->fCompl ^ Abc_LitIsCompl(pCut1->iFunc)) ? ~Truth1p : Truth1p;
        tC = (fComplC ^ pCutC->fCompl ^ Abc_LitIsCompl(pCutC->iFunc)) ? ~TruthCp : TruthCp;
        t = (tC & t1) | (~tC & t0);
    }

    // find configuration
    Config = Mpm_CutCheckDsd6( p, t );
    if ( Config == -1 )
    {
        p->nNonDsd++;
        return 0;
    }

    // get the class
    iClass = Config >> 17;
    fCompl = (Config >> 16) & 1;
    Config &= 0xFFFF;

    // check if the gate exists
    if ( p->pPars->fMap4Gates )
    {
        if ( Vec_IntSize(Vec_WecEntry(p->vNpnConfigs, iClass)) == 0 )
        {
            p->nNoMatch++;
            return 0;
        }
    }

    // set the function
    pCut->iFunc = Abc_Var2Lit( iClass, fCompl );

if ( fVerbose )
{
Mpm_CutPrint( pCut0 );
Mpm_CutPrint( pCut1 );
Mpm_CutPrint( pCut );
}

    // update cut
    assert( (Config >> 6) < 720 );
    for ( i = 0; i < (int)pCut->nLeaves; i++ )
        pLeavesNew[(int)(p->Perm6[Config >> 6][i])] = Abc_LitNotCond( pCut->pLeaves[i], (Config >> i) & 1 );
    pCut->nLeaves = p->pDsd6[iClass].nVars;
    for ( i = 0; i < (int)pCut->nLeaves; i++ )
        assert( pLeavesNew[i] != -1 );
    for ( i = 0; i < (int)pCut->nLeaves; i++ )
        pCut->pLeaves[i] = pLeavesNew[i];
    p->nCountDsd[iClass]++;
    p->nSmallSupp += (int)(pCut->nLeaves < 2);

if ( fVerbose )
{
printf( "Computed " );
Mpm_CutPrint( pCut );
printf( "\n" );
}
    return 1;
}

int Mpm_CutComputeTruth	(	Mpm_Man_t *	p,
		Mpm_Cut_t *	pCut,
		Mpm_Cut_t *	pCut0,
		Mpm_Cut_t *	pCut1,
		Mpm_Cut_t *	pCutC,
		int	fCompl0,
		int	fCompl1,
		int	fComplC,
		int	Type
	)

Definition at line 215 of file mpmTruth.c.

{
    int RetValue;
    if ( p->nLutSize <= 6 )
        RetValue = Mpm_CutComputeTruth6( p, pCut, pCut0, pCut1, pCutC, fCompl0, fCompl1, fComplC, Type );
    else
        RetValue = Mpm_CutComputeTruth7( p, pCut, pCut0, pCut1, pCutC, fCompl0, fCompl1, fComplC, Type );
#ifdef MPM_TRY_NEW
    {
        extern unsigned Abc_TtCanonicize( word * pTruth, int nVars, char * pCanonPerm );
        char pCanonPerm[16];
        memcpy( p->Truth0, p->Truth, sizeof(word) * p->nTruWords );
        Abc_TtCanonicize( p->Truth0, pCut->nLimit, pCanonPerm );
    }
#endif
    return RetValue;
}

static Mpm_Cut_t* Mpm_CutFetch ( Mpm_Man_t *  p, int  h  )

inlinestatic

Definition at line 175 of file mpmInt.h.

{ Mpm_Cut_t * pCut = (Mpm_Cut_t *)Mmr_StepEntry( p->pManCuts, h );  assert( Mpm_CutWordNum(pCut->nLeaves) == (h & p->pManCuts->uMask) ); return pCut; }

static int Mpm_CutLeafNum ( Mpm_Cut_t *  pCut )

inlinestatic

Definition at line 182 of file mpmInt.h.

{ return pCut->nLeaves;                                           }

void Mpm_CutPrint

(

Mpm_Cut_t *

pCut

)

Definition at line 103 of file mpmMap.c.

{ 
    int i;
    printf( "%d : { ", pCut->nLeaves );
    for ( i = 0; i < (int)pCut->nLeaves; i++ )
        printf( "%d ", pCut->pLeaves[i] );
    printf( "}\n" );
}

static word* Mpm_CutTruth ( Mpm_Man_t *  p, int  iFunc  )

inlinestatic

Definition at line 183 of file mpmInt.h.

{ return Vec_MemReadEntry(p->vTtMem, iFunc);                      }

word Mpm_CutTruthFromDsd	(	Mpm_Man_t *	pMan,
		Mpm_Cut_t *	pCut,
		int	iClass
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 883 of file mpmDsd.c.

{
    int i;
    word uTruth = pMan->pDsd6[iClass].uTruth;
    assert( pMan->pDsd6[iClass].nVars == (int)pCut->nLeaves );
    for ( i = 0; i < (int)pCut->nLeaves; i++ )
        if ( Abc_LitIsCompl(pCut->pLeaves[i]) )
            uTruth = Abc_Tt6Flip( uTruth, i ); 
    return uTruth;
}

static int Mpm_CutWordNum ( int  nLeaves )

inlinestatic

Definition at line 174 of file mpmInt.h.

{ return ((sizeof(Mpm_Cut_t) + (nLeaves << 2)) >> 3);             }

void Mpm_LibLutFree

(

Mpm_LibLut_t *

pLib

)

Definition at line 60 of file mpmLib.c.

{
    if ( pLib == NULL )
        return;
    ABC_FREE( pLib->pName );
    ABC_FREE( pLib );
}

Mpm_LibLut_t* Mpm_LibLutSetSimple

(

int

nLutSize

)

DECLARATIONS ///.

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

FileName [mpmLib.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Configurable technology mapper.]

Synopsis [DSD manipulation for 6-input functions.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 1, 2013.]

Revision [

Id:

mpmLib.c,v 1.00 2013/06/01 00:00:00 alanmi Exp

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file mpmLib.c.

{
    Mpm_LibLut_t * pLib;
    int i, k;
    assert( nLutSize <= MPM_VAR_MAX );
    pLib = ABC_CALLOC( Mpm_LibLut_t, 1 );
    pLib->LutMax = nLutSize;
    for ( i = 1; i <= pLib->LutMax; i++ )
    {
        pLib->pLutAreas[i] = MPM_UNIT_AREA;
        for ( k = 0; k < i; k++ )
            pLib->pLutDelays[i][k] = MPM_UNIT_TIME;
    }
    return pLib;
}

static void Mpm_ManCleanMapRefs ( Mpm_Man_t *  p )

inlinestatic

Definition at line 188 of file mpmInt.h.

{ Vec_IntFill( &p->vMapRefs, Mig_ManObjNum(p->pMig), 0 );         }

static void Mpm_ManCleanRequired ( Mpm_Man_t *  p )

inlinestatic

Definition at line 195 of file mpmInt.h.

{ Vec_IntFill(&p->vRequireds,Mig_ManObjNum(p->pMig),ABC_INFINITY);}

Vec_Wec_t* Mpm_ManFindDsdMatches	(	Mpm_Man_t *	p,
		void *	pScl
	)

DECLARATIONS ///.

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

FileName [mpmGates.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Configurable technology mapper.]

Synopsis [Standard-cell mapping.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 1, 2013.]

Revision [

Id:

mpmGates.c,v 1.00 2013/06/01 00:00:00 alanmi Exp

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

Synopsis [Finds matches fore each DSD class.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file mpmGates.c.

{
    int fVerbose = p->pPars->fVeryVerbose;
    SC_Lib * pLib = (SC_Lib *)pScl;
    Vec_Wec_t * vClasses;
    Vec_Int_t * vClass;
    SC_Cell * pRepr;
    int i, Config, iClass;
    word Truth;
    vClasses = Vec_WecStart( 600 );
    SC_LibForEachCellClass( pLib, pRepr, i )
    {
        if ( pRepr->n_inputs > 6 || pRepr->n_outputs > 1 )
        {
            if ( fVerbose )
            printf( "Skipping cell %s with %d inputs and %d outputs\n", pRepr->pName, pRepr->n_inputs, pRepr->n_outputs );
            continue;
        }
        Truth = *Vec_WrdArray( SC_CellPin(pRepr, pRepr->n_inputs)->vFunc );
        Config = Mpm_CutCheckDsd6( p, Truth );
        if ( Config == -1 )
        {
            if ( fVerbose )
            printf( "Skipping cell %s with non-DSD function\n", pRepr->pName );
            continue;
        }
        iClass = Config >> 17;
        Config = (pRepr->Id << 17) | (Config & 0x1FFFF);
        // write gate and NPN config for this DSD class
        vClass = Vec_WecEntry( vClasses, iClass );
        Vec_IntPush( vClass, Config );
        if ( !fVerbose )
            continue;

        printf( "Gate %5d  %-30s : ", pRepr->Id, pRepr->pName );
        printf( "Class %3d  ", iClass );
        printf( "Area %10.3f  ", pRepr->area );
        Extra_PrintBinary( stdout, (unsigned *)&Config, 17 );
        printf( "   " );
        Kit_DsdPrintFromTruth( (unsigned *)&Truth, pRepr->n_inputs ); printf( "\n" );
    }
    return vClasses;
}

void* Mpm_ManFromIfLogic

(

Mpm_Man_t *

pMan

)

Definition at line 213 of file mpmAbc.c.

{
    Gia_Man_t * pNew;
    Mpm_Cut_t * pCutBest;
    Mig_Obj_t * pObj, * pFanin;
    Vec_Int_t * vMapping, * vMapping2, * vPacking = NULL;
    Vec_Int_t * vLeaves, * vLeaves2, * vCover;
    word uTruth, * pTruth = &uTruth;
    int i, k, Entry, iLitNew;
//    assert( !pMan->pPars->fDeriveLuts || pMan->pPars->fTruth );
    // start mapping and packing
    vMapping  = Vec_IntStart( Mig_ManObjNum(pMan->pMig) );
    vMapping2 = Vec_IntStart( 1 );
    if ( 0 ) // pMan->pPars->fDeriveLuts && pMan->pPars->pLutStruct )
    {
        vPacking = Vec_IntAlloc( 1000 );
        Vec_IntPush( vPacking, 0 );
    }
    // create new manager
    pNew = Gia_ManStart( Mig_ManObjNum(pMan->pMig) );
    // iterate through nodes used in the mapping
    vCover   = Vec_IntAlloc( 1 << 16 );
    vLeaves  = Vec_IntAlloc( 16 );
    vLeaves2 = Vec_IntAlloc( 16 );
    Mig_ManCleanCopy( pMan->pMig );
    Mig_ManForEachObj( pMan->pMig, pObj )
    {
        if ( !Mpm_ObjMapRef(pMan, pObj) && !Mig_ObjIsTerm(pObj) )
            continue;
        if ( Mig_ObjIsNode(pObj) )
        {
            // collect leaves of the best cut
            Vec_IntClear( vLeaves );
            pCutBest = Mpm_ObjCutBestP( pMan, pObj );
            Mpm_CutForEachLeaf( pMan->pMig, pCutBest, pFanin, k )
                Vec_IntPush( vLeaves, Mig_ObjCopy(pFanin) );
            if ( pMan->pPars->fDeriveLuts && (pMan->pPars->fUseTruth || pMan->pPars->fUseDsd) )
            {
                extern int Gia_ManFromIfLogicNode( void * p, Gia_Man_t * pNew, int iObj, Vec_Int_t * vLeaves, Vec_Int_t * vLeavesTemp, 
                    word * pRes, char * pStr, Vec_Int_t * vCover, Vec_Int_t * vMapping, Vec_Int_t * vMapping2, Vec_Int_t * vPacking, int fCheck75, int fCheck44e );
                if ( pMan->pPars->fUseTruth )
                    pTruth = Mpm_CutTruth(pMan, Abc_Lit2Var(pCutBest->iFunc));
                else
                    uTruth = Mpm_CutTruthFromDsd( pMan, pCutBest, Abc_Lit2Var(pCutBest->iFunc) );
//                Kit_DsdPrintFromTruth( pTruth, Vec_IntSize(vLeaves) );  printf( "\n" );
                // perform decomposition of the cut
                iLitNew = Gia_ManFromIfLogicNode( NULL, pNew, Mig_ObjId(pObj), vLeaves, vLeaves2, pTruth, NULL, vCover, vMapping, vMapping2, vPacking, 0, 0 );
                iLitNew = Abc_LitNotCond( iLitNew, pCutBest->fCompl ^ Abc_LitIsCompl(pCutBest->iFunc) );
            }
            else
            {
                // perform one of the two types of mapping: with and without structures
                iLitNew = Mpm_ManNodeIfToGia( pNew, pMan, pObj, vLeaves, 0 );
                // write mapping
                Vec_IntSetEntry( vMapping, Abc_Lit2Var(iLitNew), Vec_IntSize(vMapping2) );
                Vec_IntPush( vMapping2, Vec_IntSize(vLeaves) );
                Vec_IntForEachEntry( vLeaves, Entry, k )
                    assert( Abc_Lit2Var(Entry) < Abc_Lit2Var(iLitNew) );
                Vec_IntForEachEntry( vLeaves, Entry, k )
                    Vec_IntPush( vMapping2, Abc_Lit2Var(Entry)  );
                Vec_IntPush( vMapping2, Abc_Lit2Var(iLitNew) );
            }
        }
        else if ( Mig_ObjIsCi(pObj) )
            iLitNew = Gia_ManAppendCi(pNew);
        else if ( Mig_ObjIsCo(pObj) )
            iLitNew = Gia_ManAppendCo( pNew, Abc_LitNotCond(Mig_ObjCopy(Mig_ObjFanin0(pObj)), Mig_ObjFaninC0(pObj)) );
        else if ( Mig_ObjIsConst0(pObj) )
        {
            iLitNew = 0;
            // create const LUT
            Vec_IntWriteEntry( vMapping, 0, Vec_IntSize(vMapping2) );
            Vec_IntPush( vMapping2, 0 );
            Vec_IntPush( vMapping2, 0 );
        }
        else assert( 0 );
        Mig_ObjSetCopy( pObj, iLitNew );
    }
    Vec_IntFree( vCover );
    Vec_IntFree( vLeaves );
    Vec_IntFree( vLeaves2 );
//    printf( "Mapping array size:  IfMan = %d. Gia = %d. Increase = %.2f\n", 
//        Mig_ManObjNum(pMan), Gia_ManObjNum(pNew), 1.0 * Gia_ManObjNum(pNew) / Mig_ManObjNum(pMan) );
    // finish mapping 
    if ( Vec_IntSize(vMapping) > Gia_ManObjNum(pNew) )
        Vec_IntShrink( vMapping, Gia_ManObjNum(pNew) );
    else
        Vec_IntFillExtra( vMapping, Gia_ManObjNum(pNew), 0 );
    assert( Vec_IntSize(vMapping) == Gia_ManObjNum(pNew) );
    Vec_IntForEachEntry( vMapping, Entry, i )
        if ( Entry > 0 )
            Vec_IntAddToEntry( vMapping, i, Gia_ManObjNum(pNew) );
    Vec_IntAppend( vMapping, vMapping2 );
    Vec_IntFree( vMapping2 );
    // attach mapping and packing
    assert( pNew->vMapping == NULL );
    assert( pNew->vPacking == NULL );
    pNew->vMapping = vMapping;
    pNew->vPacking = vPacking;
    // verify that COs have mapping
    {
        Gia_Obj_t * pObj;
        Gia_ManForEachCo( pNew, pObj, i )
           assert( !Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) || Gia_ObjIsLut(pNew, Gia_ObjFaninId0p(pNew, pObj)) );
    }
    return pNew;
}

void Mpm_ManPerform

(

Mpm_Man_t *

p

)

Definition at line 833 of file mpmMap.c.

{
    if ( p->pPars->fMap4Cnf )
    {
        p->pCutCmp = Mpm_CutCompareArea;
        Mpm_ManPerformRound( p );   
    }
    else
    {
        p->pCutCmp = Mpm_CutCompareDelay;
        Mpm_ManPerformRound( p );
        if ( p->pPars->fOneRound )
            return;
    
        p->pCutCmp = Mpm_CutCompareDelay2;
        Mpm_ManPerformRound( p );
    
        p->pCutCmp = Mpm_CutCompareArea;
        Mpm_ManPerformRound( p );   

        p->fMainRun = 1;

        p->pCutCmp = Mpm_CutCompareArea;
        Mpm_ManComputeEstRefs( p );
        Mpm_ManPerformRound( p );

        p->pCutCmp = Mpm_CutCompareArea2;
        Mpm_ManComputeEstRefs( p );
        Mpm_ManPerformRound( p );
    }
}

void Mpm_ManPrecomputePerms

(

Mpm_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 755 of file mpmDsd.c.

{
    int nVars = 6;
    // 0(1:1) 1(2:1) 2(4:2) 3(10:6) 4(33:23) 5(131:98) 6(595:464)
    int nClasses[7] = { 1, 2, 4, 10, 33, 131, 595 };
    int nPerms = Extra_Factorial( nVars );
//    int nSwaps = (1 << nVars);
    int * pComp, * pPerm;
    int i, k, x, One, OneCopy, Num;
    Vec_Int_t * vVars;
    abctime clk = Abc_Clock();
    assert( p->pDsd6 == NULL );
    p->pDsd6 = s_DsdClass6;
    // precompute schedules
    pComp = Extra_GreyCodeSchedule( nVars );
    pPerm = Extra_PermSchedule( nVars );
    // map numbers into perms
    p->vMap2Perm = Vec_IntStartFull( (1<<(3*nVars)) );
    // store permutations
    One = 0;
    for ( x = 0; x < nVars; x++ )
    {
        p->Perm6[0][x] = (char)x;
        One |= (x << (3*x));
    }
//    Vec_IntWriteEntry( p->vMap2Perm, One, 0 );
    OneCopy = One;
    for ( k = 0; k < nPerms; k++ )
    {
        if ( k > 0 )
        for ( x = 0; x < nVars; x++ )
            p->Perm6[k][x] = p->Perm6[k-1][x];
        ABC_SWAP( char, p->Perm6[k][pPerm[k]], p->Perm6[k][pPerm[k]+1] );

        Num = ( (One >> (3*(pPerm[k]  ))) ^ (One >> (3*(pPerm[k]+1))) ) & 7;
        One ^=  (Num << (3*(pPerm[k]  )));
        One ^=  (Num << (3*(pPerm[k]+1)));

        Vec_IntWriteEntry( p->vMap2Perm, One, k );
        
//        Mpm_ManPrintPerm( One );
//        for ( x = 0; x < nVars; x++ )
//            printf( "%d ", p->Perm6[k][x] );
//        printf( "\n" );
    }
    assert( OneCopy == One );
    // fill in the gaps
    vVars = Vec_IntAlloc( 6 );
    Vec_IntForEachEntry( p->vMap2Perm, Num, i )
    {
        // mark used variables
        int Count = 0;
        One = i;
        Vec_IntFill( vVars, 6, 0 );
        for ( k = 0; k < nVars; k++ )
        {
            int iVar = ((One >> (3*k)) & 7);
            if ( iVar >= nVars && iVar < 7 )
                break;
            if ( iVar != 7 )
            {
                if ( Vec_IntEntry( vVars, iVar ) == 1 )
                    break;
                Vec_IntWriteEntry( vVars, iVar, 1 );
                Count++;
            }
        }
        // skip ones with dups and complete
        if ( k < nVars || Count == nVars )
            continue;
        // find unused variables
        for ( x = k = 0; k < 6; k++ )
            if ( Vec_IntEntry(vVars, k) == 0 )
                Vec_IntWriteEntry( vVars, x++, k );
        Vec_IntShrink( vVars, x );
        // fill in used variables
        x = 0;
        for ( k = 0; k < nVars; k++ )
        {
            int iVar = ((One >> (3*k)) & 7);
            if ( iVar == 7 )
                One ^= ((Vec_IntEntry(vVars, x++) ^ 7) << (3*k));
        }
        assert( x == Vec_IntSize(vVars) );
        // save this one
        assert( Vec_IntEntry( p->vMap2Perm, One ) != -1 );
        Vec_IntWriteEntry( p->vMap2Perm, i, Vec_IntEntry(p->vMap2Perm, One) );
/*
        // mapping
        Mpm_ManPrintPerm( i );
        printf( "->  " );
        Mpm_ManPrintPerm( One );
        printf( "\n" );
*/
    }
    Vec_IntFree( vVars );

    // store permuted truth tables
    assert( p->vPerm6 == NULL );
    p->vPerm6 = Vec_WrdAlloc( nPerms * 595 );
    for ( i = 0; i < nClasses[nVars]; i++ )
    {
        word uTruth = s_DsdClass6[i].uTruth;
        for ( k = 0; k < nPerms; k++ )
        {
            uTruth = Abc_Tt6SwapAdjacent( uTruth, pPerm[k] );
            Vec_WrdPush( p->vPerm6, uTruth );
        }
        assert( uTruth == s_DsdClass6[i].uTruth );
    }
    ABC_FREE( pPerm );
    ABC_FREE( pComp );
    // build hash table
    p->pHash = Mpm_ManBuildHashTable( &p->vConfgRes );
    Abc_PrintTime( 1, "Setting up DSD information", Abc_Clock() - clk );
}

void Mpm_ManPrepare

(

Mpm_Man_t *

p

)

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

Synopsis [Technology mapping experiment.]

Description []

SideEffects []

SeeAlso []

Definition at line 794 of file mpmMap.c.

{
    Mig_Obj_t * pObj;
    int i, hCut;
    Mig_ManForEachCi( p->pMig, pObj, i )
    {
        hCut = Mpm_CutCreateUnit( p, Mig_ObjId(pObj) );
        Mpm_ObjSetCutBest( p, pObj, hCut );
        Mpm_ObjSetCutList( p, pObj, hCut );
    }
    Mig_ManForEachCand( p->pMig, pObj )
        Mpm_ObjSetEstRef( p, pObj, MPM_UNIT_REFS * Mig_ObjRefNum(pObj) );
}

void Mpm_ManPrintDsdStats

(

Mpm_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 665 of file mpmDsd.c.

{
    int i, Absent = 0;
    for ( i = 0; i < 595; i++ )
    {
        if ( p->nCountDsd[i] == 0 )
        {
            Absent++;
            continue;
        }
        if ( p->pPars->fVeryVerbose )
        {
            printf( "%5d  :  ", i );
            printf( "%-20s   ", p->pDsd6[i].pStr );
            printf( "%8d ",     p->nCountDsd[i] );
            printf( "\n" );
        }
    }
    printf( "Unused classes = %d (%.2f %%).  ",  Absent, 100.0 * Absent / 595 );
    printf( "Non-DSD cuts = %d (%.2f %%).  ",   p->nNonDsd, 100.0 * p->nNonDsd / p->nCutsMergedAll );
    printf( "No-match cuts = %d (%.2f %%).\n",  p->nNoMatch, 100.0 * p->nNoMatch / p->nCutsMergedAll );
}

void Mpm_ManPrintPerm

(

unsigned

s

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 736 of file mpmDsd.c.

{
    int i;
    for ( i = 0; i < 6; i++ )
        printf( "%d ", (s >> (3*i)) & 7 );
    printf( "  " );
}

void Mpm_ManPrintStats

(

Mpm_Man_t *

p

)

Definition at line 173 of file mpmMan.c.

{
    printf( "Memory usage:  Mig = %.2f MB  Map = %.2f MB  Cut = %.2f MB    Total = %.2f MB.  ", 
        1.0 * Mig_ManObjNum(p->pMig) * sizeof(Mig_Obj_t) / (1 << 20), 
        1.0 * Mig_ManObjNum(p->pMig) * 48 / (1 << 20), 
        1.0 * Mmr_StepMemory(p->pManCuts) / (1 << 17), 
        1.0 * Mig_ManObjNum(p->pMig) * sizeof(Mig_Obj_t) / (1 << 20) + 
        1.0 * Mig_ManObjNum(p->pMig) * 48 / (1 << 20) +
        1.0 * Mmr_StepMemory(p->pManCuts) / (1 << 17) );
    if ( p->timeDerive )
    {
        printf( "\n" );
        p->timeTotal = Abc_Clock() - p->timeTotal;
        p->timeOther = p->timeTotal - p->timeDerive;

        Abc_Print( 1, "Runtime breakdown:\n" );
        ABC_PRTP( "Complete cut computation   ", p->timeDerive , p->timeTotal );
        ABC_PRTP( "- Merging cuts             ", p->timeMerge  , p->timeTotal );
        ABC_PRTP( "- Evaluting cut parameters ", p->timeEval   , p->timeTotal );
        ABC_PRTP( "- Checking cut containment ", p->timeCompare, p->timeTotal );
        ABC_PRTP( "- Adding cuts to storage   ", p->timeStore  , p->timeTotal );
        ABC_PRTP( "Other                      ", p->timeOther  , p->timeTotal );
        ABC_PRTP( "TOTAL                      ", p->timeTotal  , p->timeTotal );
    }
    else
        Abc_PrintTime( 1, "Time", Abc_Clock() - p->timeTotal );
}

void Mpm_ManPrintStatsInit

(

Mpm_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 166 of file mpmMan.c.

{
    printf( "K = %d.  C = %d.  Cand = %d. XOR = %d. MUX = %d. Choice = %d.  CutMin = %d. Truth = %d. DSD = %d.\n", 
        p->nLutSize, p->nNumCuts, Mig_ManCandNum(p->pMig), 
        Mig_ManXorNum(p->pMig), Mig_ManMuxNum(p->pMig), p->pMig->nChoices, 
        p->pPars->fCutMin, p->pPars->fUseTruth, p->pPars->fUseDsd );
}

Mpm_Man_t* Mpm_ManStart	(	Mig_Man_t *	pMig,
		Mpm_Par_t *	pPars
	)

DECLARATIONS ///.

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

FileName [mpm.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Configurable technology mapper.]

Synopsis []

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 1, 2013.]

Revision [

Id:

mpm.c,v 1.00 2013/06/01 00:00:00 alanmi Exp

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file mpmMan.c.

{
    Mpm_Man_t * p;
    int i;
    assert( sizeof(Mpm_Uni_t) % sizeof(word) == 0 );      // aligned info to word boundary
    assert( pPars->nNumCuts <= MPM_CUT_MAX );
    assert( !pPars->fUseTruth || pPars->pLib->LutMax <= 16 );
    assert( !pPars->fUseDsd || pPars->pLib->LutMax <= 6 );
    Mig_ManSetRefs( pMig );
    // alloc
    p = ABC_CALLOC( Mpm_Man_t, 1 );
    p->pMig      = pMig;
    p->pPars     = pPars;
    p->pLibLut   = pPars->pLib;
    p->nLutSize  = pPars->pLib->LutMax;
    p->nTruWords = pPars->fUseTruth ? Abc_Truth6WordNum(p->nLutSize) : 0;
    p->nNumCuts  = pPars->nNumCuts;
    // cuts
    assert( Mpm_CutWordNum(32) < 32 ); // using 5 bits for word count
    p->pManCuts  = Mmr_StepStart( 13, Abc_Base2Log(Mpm_CutWordNum(p->nLutSize) + 1) );
    Vec_PtrGrow( &p->vFreeUnits, p->nNumCuts + 1 );
    for ( i = p->nNumCuts; i >= 0; i-- )
        Vec_PtrPush( &p->vFreeUnits, p->pCutUnits + i );
    p->vTemp     = Vec_PtrAlloc( 1000 );
    // mapping attributes
    Vec_IntFill( &p->vCutBests, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vCutLists, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vMigRefs, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vMapRefs, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vEstRefs, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vRequireds, Mig_ManObjNum(pMig), ABC_INFINITY );
    Vec_IntFill( &p->vTimes, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vAreas, Mig_ManObjNum(pMig), 0 );
    Vec_IntFill( &p->vEdges, Mig_ManObjNum(pMig), 0 );
    // start DSD manager
    assert( !p->pPars->fUseTruth || !p->pPars->fUseDsd );
    if ( p->pPars->fUseTruth )
    { 
        p->vTtMem = Vec_MemAlloc( p->nTruWords, 12 ); // 32 KB/page for 6-var functions
        Vec_MemHashAlloc( p->vTtMem, 10000 );
        p->funcCst0 = Vec_MemHashInsert( p->vTtMem, p->Truth );
        Abc_TtUnit( p->Truth, p->nTruWords );
        p->funcVar0 = Vec_MemHashInsert( p->vTtMem, p->Truth );
    }
    else if ( p->pPars->fUseDsd )
    {
        Mpm_ManPrecomputePerms( p );
        p->funcVar0 = 1;
    }
    // finish
    p->timeTotal = Abc_Clock();
    pMig->pMan = p;
    return p;
}

void Mpm_ManStop

(

Mpm_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 111 of file mpmMan.c.

{
    if ( p->pPars->fUseTruth && p->pPars->fVeryVerbose )
    {
        char * pFileName = "truths.txt";
        FILE * pFile = fopen( pFileName, "wb" );
        Vec_MemDump( pFile, p->vTtMem );
        fclose( pFile );
        printf( "Dumped %d %d-var truth tables into file \"%s\" (%.2f MB).\n", 
            Vec_MemEntryNum(p->vTtMem), p->nLutSize, pFileName,
            (16.0 * p->nTruWords + 1.0) * Vec_MemEntryNum(p->vTtMem) / (1 << 20) );
    }
    if ( p->pPars->fUseDsd && p->pPars->fVerbose )
        Mpm_ManPrintDsdStats( p );
    if ( p->vTtMem ) 
    {
        Vec_MemHashFree( p->vTtMem );
        Vec_MemFree( p->vTtMem );
    }
    if ( p->pHash )
    {
        Vec_WrdFree( p->vPerm6 );
        Vec_IntFree( p->vMap2Perm );
        Vec_IntFree( p->vConfgRes );
        Vec_IntFree( p->pHash->vData );
        Hsh_IntManStop( p->pHash );
    }
    Vec_WecFreeP( &p->vNpnConfigs );
    Vec_PtrFree( p->vTemp );
    Mmr_StepStop( p->pManCuts );
    ABC_FREE( p->vFreeUnits.pArray );
    // mapping attributes
    ABC_FREE( p->vCutBests.pArray );
    ABC_FREE( p->vCutLists.pArray );
    ABC_FREE( p->vMigRefs.pArray );
    ABC_FREE( p->vMapRefs.pArray );
    ABC_FREE( p->vEstRefs.pArray );
    ABC_FREE( p->vRequireds.pArray );
    ABC_FREE( p->vTimes.pArray );
    ABC_FREE( p->vAreas.pArray );
    ABC_FREE( p->vEdges.pArray );
    ABC_FREE( p );
}

static int Mpm_ObjArea ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 202 of file mpmInt.h.

{ return Vec_IntEntry(&p->vAreas, Mig_ObjId(pObj));               }

static int Mpm_ObjCutBest ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

MACRO DEFINITIONS ///.

Definition at line 171 of file mpmInt.h.

{ return Vec_IntEntry(&p->vCutBests, Mig_ObjId(pObj));            }

static Mpm_Cut_t* Mpm_ObjCutBestP ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 176 of file mpmInt.h.

{ return Mpm_CutFetch( p, Mpm_ObjCutBest(p, pObj) );              }

static int Mpm_ObjCutList ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 178 of file mpmInt.h.

{ return Vec_IntEntry(&p->vCutLists, Mig_ObjId(pObj));            }

static int* Mpm_ObjCutListP ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 179 of file mpmInt.h.

{ return Vec_IntEntryP(&p->vCutLists, Mig_ObjId(pObj));           }

static int Mpm_ObjEdge ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 205 of file mpmInt.h.

{ return Vec_IntEntry(&p->vEdges, Mig_ObjId(pObj));               }

static int Mpm_ObjEstRef ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 192 of file mpmInt.h.

{ return Vec_IntEntry(&p->vEstRefs, Mig_ObjId(pObj));             }

static int Mpm_ObjMapRef ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 189 of file mpmInt.h.

{ return Vec_IntEntry(&p->vMapRefs, Mig_ObjId(pObj));             }

static int Mpm_ObjRequired ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 196 of file mpmInt.h.

{ return Vec_IntEntry(&p->vRequireds, Mig_ObjId(pObj));           }

static void Mpm_ObjSetArea ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 203 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vAreas, Mig_ObjId(pObj), i);              }

static void Mpm_ObjSetCutBest ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 172 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vCutBests, Mig_ObjId(pObj), i);           }

static void Mpm_ObjSetCutList ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 180 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vCutLists, Mig_ObjId(pObj), i);           }

static void Mpm_ObjSetEdge ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 206 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vEdges, Mig_ObjId(pObj), i);              }

static void Mpm_ObjSetEstRef ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 193 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vEstRefs, Mig_ObjId(pObj), i);            }

static void Mpm_ObjSetMapRef ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 190 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vMapRefs, Mig_ObjId(pObj), i);            }

static void Mpm_ObjSetRequired ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 197 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vRequireds, Mig_ObjId(pObj), i);          }

static void Mpm_ObjSetTime ( Mpm_Man_t *  p, Mig_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 200 of file mpmInt.h.

{ Vec_IntWriteEntry(&p->vTimes, Mig_ObjId(pObj), i);              }

static int Mpm_ObjTime ( Mpm_Man_t *  p, Mig_Obj_t *  pObj  )

inlinestatic

Definition at line 199 of file mpmInt.h.

{ return Vec_IntEntry(&p->vTimes, Mig_ObjId(pObj));               }

static void Mpm_VarsClear ( int *  V2P, int *  P2V, int  nVars  )

inlinestatic

Definition at line 208 of file mpmInt.h.

{ int i; for ( i = 0; i < nVars; i++ ) V2P[i] = P2V[i] = i;       }

static void Mpm_VarsSwap ( int *  V2P, int *  P2V, int  iVar, int  jVar  )

inlinestatic

Definition at line 209 of file mpmInt.h.

{ V2P[P2V[iVar]] = jVar; V2P[P2V[jVar]] = iVar; P2V[iVar] ^= P2V[jVar]; P2V[jVar] ^= P2V[iVar]; P2V[iVar] ^= P2V[jVar];  }