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"

Include dependency graph for mpmInt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Mpm_Cut_t_
struct	Mpm_Uni_t_
struct	Mpm_Dsd_t_
struct	Mpm_Man_t_

Macros
#define	MPM_CUT_MAX   32
	INCLUDES ///.
#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)
#define	Mpm_ObjForEachCutSafe(p, pObj, hCut, pCut, hNext)
#define	Mpm_CutForEachLeafId(pCut, iLeafId, i)
#define	Mpm_CutForEachLeafLit(pCut, iLeafLit, i)
#define	Mpm_CutForEachLeaf(p, pCut, pLeaf, i)

Typedefs
typedef struct Mpm_Cut_t_	Mpm_Cut_t
	BASIC TYPES ///.
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
Mig_Man_t *	Mig_ManCreate (void *pGia)
	FUNCTION DECLARATIONS ///.
void *	Mpm_ManFromIfLogic (Mpm_Man_t *pMan)
Mpm_Man_t *	Mpm_ManStart (Mig_Man_t *pMig, Mpm_Par_t *pPars)
	DECLARATIONS ///.
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 ///.
Mpm_LibLut_t *	Mpm_LibLutSetSimple (int nLutSize)
	DECLARATIONS ///.
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

MPM_CUT_MAX

#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.

Mpm_CutForEachLeaf

#define Mpm_CutForEachLeaf	(		p,
			pCut,
			pLeaf,
			i )

Value:

    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_CutForEachLeaf( p, pCut, pLeaf, i )                          \
    for ( i = 0; i < (int)pCut->nLeaves && (pLeaf = Mig_ManObj(p, Abc_Lit2Var(pCut->pLeaves[i]))); i++ )

Mpm_CutForEachLeafId

#define Mpm_CutForEachLeafId	(		pCut,
			iLeafId,
			i )

Value:

    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_CutForEachLeafId( pCut, iLeafId, i )                         \
    for ( i = 0; i < (int)pCut->nLeaves && ((iLeafId = Abc_Lit2Var(pCut->pLeaves[i])), 1); i++ )

Mpm_CutForEachLeafLit

#define Mpm_CutForEachLeafLit	(		pCut,
			iLeafLit,
			i )

Value:

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

Definition at line 220 of file mpmInt.h.

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

Mpm_ObjForEachCut

#define Mpm_ObjForEachCut	(		p,
			pObj,
			hCut,
			pCut )

Value:

    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_ObjForEachCut( p, pObj, hCut, pCut )                         \
    for ( hCut = Mpm_ObjCutList(p, pObj); hCut && (pCut = Mpm_CutFetch(p, hCut)); hCut = pCut->hNext )

Mpm_ObjForEachCutSafe

#define Mpm_ObjForEachCutSafe	(		p,
			pObj,
			hCut,
			pCut,
			hNext )

Value:

    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_ObjForEachCutSafe( p, pObj, hCut, pCut, hNext )              \
    for ( hCut = Mpm_ObjCutList(p, pObj); hCut && (pCut = Mpm_CutFetch(p, hCut)) && ((hNext = pCut->hNext), 1); hCut = hNext )

MPM_UNIT_AREA

#define MPM_UNIT_AREA   20

Definition at line 53 of file mpmInt.h.

MPM_UNIT_EDGE

#define MPM_UNIT_EDGE   50

Definition at line 54 of file mpmInt.h.

MPM_UNIT_REFS

#define MPM_UNIT_REFS   100

Definition at line 55 of file mpmInt.h.

MPM_UNIT_TIME

#define MPM_UNIT_TIME   1

Definition at line 52 of file mpmInt.h.

Typedef Documentation

Mpm_Cut_t

typedef struct Mpm_Cut_t_ Mpm_Cut_t

BASIC TYPES ///.

Definition at line 61 of file mpmInt.h.

Mpm_Dsd_t

typedef struct Mpm_Dsd_t_ Mpm_Dsd_t

Definition at line 84 of file mpmInt.h.

Mpm_Man_t

typedef struct Mpm_Man_t_ Mpm_Man_t

Definition at line 94 of file mpmInt.h.

Mpm_Uni_t

typedef struct Mpm_Uni_t_ Mpm_Uni_t

Definition at line 71 of file mpmInt.h.

Function Documentation

Kit_DsdPrintFromTruth()

void Kit_DsdPrintFromTruth ( unsigned * pTruth, int nVars )

extern

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

Synopsis [Print the DSD formula.]

Description []

SideEffects []

SeeAlso []

Definition at line 491 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_ManCreate()

Mig_Man_t * Mig_ManCreate ( void * pGia )

extern

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

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_CutCheckDsd6()

int Mpm_CutCheckDsd6 ( Mpm_Man_t * p, word t )

extern

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

Here is the caller graph for this function:

Mpm_CutComputeDsd6()

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 )

extern

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

Here is the call graph for this function:

Mpm_CutComputeTruth()

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 )

extern

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

Here is the call graph for this function:

Mpm_CutPrint()

void Mpm_CutPrint ( Mpm_Cut_t * pCut )

extern

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

Here is the caller graph for this function:

Mpm_CutTruthFromDsd()

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

extern

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

Here is the caller graph for this function:

Mpm_LibLutFree()

void Mpm_LibLutFree ( Mpm_LibLut_t * pLib )

extern

Definition at line 60 of file mpmLib.c.

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

Mpm_LibLutSetSimple()

Mpm_LibLut_t * Mpm_LibLutSetSimple ( int nLutSize )

extern

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

Mpm_ManFindDsdMatches()

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

extern

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

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_ManFromIfLogic()

void * Mpm_ManFromIfLogic ( Mpm_Man_t * pMan )

extern

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 = 0;
//    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_ManPerform()

void Mpm_ManPerform ( Mpm_Man_t * p )

extern

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

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_ManPrecomputePerms()

void Mpm_ManPrecomputePerms ( Mpm_Man_t * p )

extern

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

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_ManPrepare()

void Mpm_ManPrepare ( Mpm_Man_t * p )

extern

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

Here is the caller graph for this function:

Mpm_ManPrintDsdStats()

void Mpm_ManPrintDsdStats ( Mpm_Man_t * p )

extern

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

Here is the caller graph for this function:

Mpm_ManPrintPerm()

void Mpm_ManPrintPerm ( unsigned s )

extern

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

Here is the caller graph for this function:

Mpm_ManPrintStats()

void Mpm_ManPrintStats ( Mpm_Man_t * p )

extern

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( "- Evaluating 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 );
}

Here is the caller graph for this function:

Mpm_ManPrintStatsInit()

void Mpm_ManPrintStatsInit ( Mpm_Man_t * p )

extern

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

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_ManStart()

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

extern

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

Here is the call graph for this function:

Here is the caller graph for this function:

Mpm_ManStop()

void Mpm_ManStop ( Mpm_Man_t * p )

extern

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

Here is the call graph for this function:

Here is the caller graph for this function: