mapper.h File Reference

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

Go to the source code of this file.

Classes
struct	Map_TimeStruct_t_

Macros
#define	Map_IsComplement(p)
	GLOBAL VARIABLES ///.
#define	Map_Regular(p)
#define	Map_Not(p)
#define	Map_NotCond(p, c)

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Map_ManStruct_t_	Map_Man_t
	INCLUDES ///.
typedef struct Map_NodeStruct_t_	Map_Node_t
typedef struct Map_NodeVecStruct_t_	Map_NodeVec_t
typedef struct Map_CutStruct_t_	Map_Cut_t
typedef struct Map_MatchStruct_t_	Map_Match_t
typedef struct Map_SuperStruct_t_	Map_Super_t
typedef struct Map_SuperLibStruct_t_	Map_SuperLib_t
typedef struct Map_HashTableStruct_t_	Map_HashTable_t
typedef struct Map_HashEntryStruct_t_	Map_HashEntry_t
typedef struct Map_TimeStruct_t_	Map_Time_t

Functions
Map_Man_t *	Map_ManCreate (int nInputs, int nOutputs, int fVerbose)
	FUNCTION DEFINITIONS ///.
Map_Node_t *	Map_NodeCreate (Map_Man_t *p, Map_Node_t *p1, Map_Node_t *p2)
void	Map_ManCreateNodeDelays (Map_Man_t *p, int LogFan)
void	Map_ManFree (Map_Man_t *pMan)
void	Map_ManPrintTimeStats (Map_Man_t *p)
void	Map_ManPrintStatsToFile (char *pName, float Area, float Delay, abctime Time)
int	Map_ManReadInputNum (Map_Man_t *p)
	FUNCTION DEFINITIONS ///.
int	Map_ManReadOutputNum (Map_Man_t *p)
int	Map_ManReadBufNum (Map_Man_t *p)
Map_Node_t **	Map_ManReadInputs (Map_Man_t *p)
Map_Node_t **	Map_ManReadOutputs (Map_Man_t *p)
Map_Node_t **	Map_ManReadBufs (Map_Man_t *p)
Map_Node_t *	Map_ManReadBufDriver (Map_Man_t *p, int i)
Map_Node_t *	Map_ManReadConst1 (Map_Man_t *p)
Map_Time_t *	Map_ManReadInputArrivals (Map_Man_t *p)
Mio_Library_t *	Map_ManReadGenLib (Map_Man_t *p)
int	Map_ManReadVerbose (Map_Man_t *p)
float	Map_ManReadAreaFinal (Map_Man_t *p)
float	Map_ManReadRequiredGlo (Map_Man_t *p)
void	Map_ManSetOutputNames (Map_Man_t *p, char **ppNames)
void	Map_ManSetAreaRecovery (Map_Man_t *p, int fAreaRecovery)
void	Map_ManSetDelayTarget (Map_Man_t *p, float DelayTarget)
void	Map_ManSetInputArrivals (Map_Man_t *p, Map_Time_t *pArrivals)
void	Map_ManSetOutputRequireds (Map_Man_t *p, Map_Time_t *pArrivals)
void	Map_ManSetObeyFanoutLimits (Map_Man_t *p, int fObeyFanoutLimits)
void	Map_ManSetNumIterations (Map_Man_t *p, int nNumIterations)
int	Map_ManReadPass (Map_Man_t *p)
void	Map_ManSetPass (Map_Man_t *p, int nPass)
int	Map_ManReadFanoutViolations (Map_Man_t *p)
void	Map_ManSetFanoutViolations (Map_Man_t *p, int nVio)
void	Map_ManSetChoiceNodeNum (Map_Man_t *p, int nChoiceNodes)
void	Map_ManSetChoiceNum (Map_Man_t *p, int nChoices)
void	Map_ManSetVerbose (Map_Man_t *p, int fVerbose)
void	Map_ManSetSwitching (Map_Man_t *p, int fSwitching)
void	Map_ManSetSkipFanout (Map_Man_t *p, int fSkipFanout)
void	Map_ManSetUseProfile (Map_Man_t *p)
void	Map_ManCreateAigIds (Map_Man_t *p, int nObjs)
Map_Man_t *	Map_NodeReadMan (Map_Node_t *p)
char *	Map_NodeReadData (Map_Node_t *p, int fPhase)
int	Map_NodeReadNum (Map_Node_t *p)
int	Map_NodeReadLevel (Map_Node_t *p)
int	Map_NodeReadAigId (Map_Node_t *p)
Map_Cut_t *	Map_NodeReadCuts (Map_Node_t *p)
Map_Cut_t *	Map_NodeReadCutBest (Map_Node_t *p, int fPhase)
Map_Node_t *	Map_NodeReadOne (Map_Node_t *p)
Map_Node_t *	Map_NodeReadTwo (Map_Node_t *p)
void	Map_NodeSetData (Map_Node_t *p, int fPhase, char *pData)
void	Map_NodeSetNextE (Map_Node_t *p, Map_Node_t *pNextE)
void	Map_NodeSetRepr (Map_Node_t *p, Map_Node_t *pRepr)
void	Map_NodeSetSwitching (Map_Node_t *p, float Switching)
void	Map_NodeSetAigId (Map_Node_t *p, int Id)
int	Map_NodeIsConst (Map_Node_t *p)
int	Map_NodeIsVar (Map_Node_t *p)
int	Map_NodeIsBuf (Map_Node_t *p)
int	Map_NodeIsAnd (Map_Node_t *p)
int	Map_NodeComparePhase (Map_Node_t *p1, Map_Node_t *p2)
Map_Super_t *	Map_CutReadSuperBest (Map_Cut_t *p, int fPhase)
Map_Super_t *	Map_CutReadSuper0 (Map_Cut_t *p)
Map_Super_t *	Map_CutReadSuper1 (Map_Cut_t *p)
int	Map_CutReadLeavesNum (Map_Cut_t *p)
Map_Node_t **	Map_CutReadLeaves (Map_Cut_t *p)
unsigned	Map_CutReadPhaseBest (Map_Cut_t *p, int fPhase)
unsigned	Map_CutReadPhase0 (Map_Cut_t *p)
unsigned	Map_CutReadPhase1 (Map_Cut_t *p)
Map_Cut_t *	Map_CutReadNext (Map_Cut_t *p)
char *	Map_SuperReadFormula (Map_Super_t *p)
Mio_Gate_t *	Map_SuperReadRoot (Map_Super_t *p)
int	Map_SuperReadNum (Map_Super_t *p)
Map_Super_t **	Map_SuperReadFanins (Map_Super_t *p)
int	Map_SuperReadFaninNum (Map_Super_t *p)
Map_Super_t *	Map_SuperReadNext (Map_Super_t *p)
int	Map_SuperReadNumPhases (Map_Super_t *p)
unsigned char *	Map_SuperReadPhases (Map_Super_t *p)
int	Map_SuperReadFanoutLimit (Map_Super_t *p)
Mio_Library_t *	Map_SuperLibReadGenLib (Map_SuperLib_t *p)
float	Map_SuperLibReadAreaInv (Map_SuperLib_t *p)
Map_Time_t	Map_SuperLibReadDelayInv (Map_SuperLib_t *p)
int	Map_SuperLibReadVarsMax (Map_SuperLib_t *p)
Map_Node_t *	Map_NodeAnd (Map_Man_t *p, Map_Node_t *p1, Map_Node_t *p2)
Map_Node_t *	Map_NodeBuf (Map_Man_t *p, Map_Node_t *p1)
void	Map_NodeSetChoice (Map_Man_t *pMan, Map_Node_t *pNodeOld, Map_Node_t *pNodeNew)
int	Map_CanonComputeSlow (unsigned uTruths[][2], int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char *puPhases, unsigned uTruthRes[])
	FUNCTION DEFINITIONS ///.
int	Map_CanonComputeFast (Map_Man_t *p, int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char *puPhases, unsigned uTruthRes[])
Map_Cut_t *	Map_CutAlloc (Map_Man_t *p)
	DECLARATIONS ///.
void	Map_CutCreateFromNode (Map_Man_t *p, Map_Super_t *pSuper, int iRoot, unsigned uPhaseRoot, int *pLeaves, int nLeaves, unsigned uPhaseLeaves)
Vec_Ptr_t *	Map_CutInternalNodes (Map_Node_t *pObj, Map_Cut_t *pCut)
int	Map_Mapping (Map_Man_t *p)
	DECLARATIONS ///.
int	Map_SuperLibDeriveFromGenlib (Mio_Library_t *pLib, int fVerbose)
void	Map_SuperLibFree (Map_SuperLib_t *p)
char *	Map_LibraryReadFormulaStep (char *pFormula, char *pStrings[], int *pnStrings)
void	Map_NetworkSweep (Abc_Ntk_t *pNet)
Map_Super_t *	Map_SuperTableLookupC (Map_SuperLib_t *pLib, unsigned uTruth[])
int	Map_ManCheckConsistency (Map_Man_t *p)
st__table *	Map_CreateTableGate2Super (Map_Man_t *p)
void	Map_ManCleanData (Map_Man_t *p)
void	Map_MappingSetupTruthTables (unsigned uTruths[][2])
void	Map_MappingSetupTruthTablesLarge (unsigned uTruths[][32])

Macro Definition Documentation

Map_IsComplement

#define Map_IsComplement

(

p

)

Value:

(((int)((ABC_PTRUINT_T) (p) & 01)))

GLOBAL VARIABLES ///.

MACRO DEFINITIONS ///

Definition at line 67 of file mapper.h.

Map_Not

#define Map_Not

(

p

)

Value:

((Map_Node_t *)((ABC_PTRUINT_T)(p) ^ 01))

Definition at line 69 of file mapper.h.

Map_NotCond

#define Map_NotCond	(		p,
			c )

Value:

((Map_Node_t *)((ABC_PTRUINT_T)(p) ^ (c)))

Definition at line 70 of file mapper.h.

Map_Regular

#define Map_Regular

(

p

)

Value:

((Map_Node_t *)((ABC_PTRUINT_T)(p) & ~01))

Definition at line 68 of file mapper.h.

Typedef Documentation

Map_Cut_t

typedef struct Map_CutStruct_t_ Map_Cut_t

Definition at line 43 of file mapper.h.

Map_HashEntry_t

typedef struct Map_HashEntryStruct_t_ Map_HashEntry_t

Definition at line 48 of file mapper.h.

Map_HashTable_t

typedef struct Map_HashTableStruct_t_ Map_HashTable_t

Definition at line 47 of file mapper.h.

Map_Man_t

typedef typedefABC_NAMESPACE_HEADER_START struct Map_ManStruct_t_ Map_Man_t

INCLUDES ///.

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

FileName [mapper.h]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Generic technology mapping engine.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 2.0. Started - June 1, 2004.]

Revision [

Id

mapper.h,v 1.11 2005/02/28 05:34:26 alanmi Exp

] PARAMETERS /// STRUCTURE DEFINITIONS ///

Definition at line 40 of file mapper.h.

Map_Match_t

typedef struct Map_MatchStruct_t_ Map_Match_t

Definition at line 44 of file mapper.h.

Map_Node_t

typedef struct Map_NodeStruct_t_ Map_Node_t

Definition at line 41 of file mapper.h.

Map_NodeVec_t

typedef struct Map_NodeVecStruct_t_ Map_NodeVec_t

Definition at line 42 of file mapper.h.

Map_Super_t

typedef struct Map_SuperStruct_t_ Map_Super_t

Definition at line 45 of file mapper.h.

Map_SuperLib_t

typedef struct Map_SuperLibStruct_t_ Map_SuperLib_t

Definition at line 46 of file mapper.h.

Map_Time_t

typedef struct Map_TimeStruct_t_ Map_Time_t

Definition at line 49 of file mapper.h.

Function Documentation

Map_CanonComputeFast()

int Map_CanonComputeFast ( Map_Man_t * p, int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char * puPhases, unsigned uTruthRes[] )

extern

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

Synopsis [Computes the N-canonical form of the Boolean function.]

Description [The N-canonical form is defined as the truth table with the minimum integer value. This function exhaustively enumerates through the complete set of 2^N phase assignments.]

SideEffects []

SeeAlso []

Definition at line 173 of file mapperCanon.c.

{
    unsigned uTruth0, uTruth1;
    unsigned uCanon0, uCanon1, uCanonBest;
    unsigned uPhaseBest = 16; // Suppress "might be used uninitialized" (asserts require < 16)
    int i, Limit;
 
    if ( nVarsMax == 6 )
        return Map_CanonComputeSlow( p->uTruths, nVarsMax, nVarsReal, uTruth, puPhases, uTruthRes );
 
    if ( nVarsReal < 5 )
    {
//        return Map_CanonComputeSlow( p->uTruths, nVarsMax, nVarsReal, uTruth, puPhases, uTruthRes );
 
        uTruth0 = uTruth[0] & 0xFFFF;
        assert( p->pCounters[uTruth0] > 0 );
        uTruthRes[0] = (p->uCanons[uTruth0] << 16) | p->uCanons[uTruth0];
        uTruthRes[1] = uTruthRes[0];
        puPhases[0] = p->uPhases[uTruth0][0];
        return 1;
    }
 
    assert( nVarsMax == 5 );
    assert( nVarsReal == 5 );
    uTruth0 = uTruth[0] & 0xFFFF;
    uTruth1 = (uTruth[0] >> 16);
    if ( uTruth1 == 0 )
    {
        uTruthRes[0] = p->uCanons[uTruth0];
        uTruthRes[1] = uTruthRes[0];
        Limit = (p->pCounters[uTruth0] > 4)? 4 : p->pCounters[uTruth0];
        for ( i = 0; i < Limit; i++ )
            puPhases[i] = p->uPhases[uTruth0][i];
        return Limit;
    }
    else if ( uTruth0 == 0 )
    {
        uTruthRes[0] = p->uCanons[uTruth1];
        uTruthRes[1] = uTruthRes[0];
        Limit = (p->pCounters[uTruth1] > 4)? 4 : p->pCounters[uTruth1];
        for ( i = 0; i < Limit; i++ )
        {
            puPhases[i] = p->uPhases[uTruth1][i];
            puPhases[i] |= (1 << 4);
        }
        return Limit;
    }
    uCanon0 = p->uCanons[uTruth0];
    uCanon1 = p->uCanons[uTruth1];
    if ( uCanon0 >= uCanon1 ) // using nCanon1 as the main one
    {
        assert( p->pCounters[uTruth1] > 0 );
        uCanonBest = 0xFFFFFFFF;
        for ( i = 0; i < p->pCounters[uTruth1]; i++ )
        {
            uCanon0 = Extra_TruthPolarize( uTruth0, p->uPhases[uTruth1][i], 4 );
            if ( uCanonBest > uCanon0 )
            {
                uCanonBest = uCanon0;
                uPhaseBest = p->uPhases[uTruth1][i];
                assert( uPhaseBest < 16 );
            }
        }
        uTruthRes[0] = (uCanon1 << 16) | uCanonBest;
        uTruthRes[1] = uTruthRes[0];
        puPhases[0] = uPhaseBest;
        return 1;
    }
    else if ( uCanon0 < uCanon1 )
    {
        assert( p->pCounters[uTruth0] > 0 );
        uCanonBest = 0xFFFFFFFF;
        for ( i = 0; i < p->pCounters[uTruth0]; i++ )
        {
            uCanon1 = Extra_TruthPolarize( uTruth1, p->uPhases[uTruth0][i], 4 );
            if ( uCanonBest > uCanon1 )
            {
                uCanonBest = uCanon1;
                uPhaseBest = p->uPhases[uTruth0][i];
                assert( uPhaseBest < 16 );
            }
        }
        uTruthRes[0] = (uCanon0 << 16) | uCanonBest;
        uTruthRes[1] = uTruthRes[0];
        puPhases[0] = uPhaseBest | (1 << 4);
        return 1;
    }
    else
    {
        assert( 0 );
        return Map_CanonComputeSlow( p->uTruths, nVarsMax, nVarsReal, uTruth, puPhases, uTruthRes );
    }
}

Here is the call graph for this function:

Map_CanonComputeSlow()

int Map_CanonComputeSlow ( unsigned uTruths[][2], int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char * puPhases, unsigned uTruthRes[] )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Computes the N-canonical form of the Boolean function.]

Description [The N-canonical form is defined as the truth table with the minimum integer value. This function exhaustively enumerates through the complete set of 2^N phase assignments.]

SideEffects []

SeeAlso []

Definition at line 48 of file mapperCanon.c.

{
    unsigned  uTruthPerm[2];
    int nMints, nPhases, m;
 
    nPhases = 0;
    nMints = (1 << nVarsReal);
    if ( nVarsMax < 6 )
    {
        uTruthRes[0] = MAP_MASK(32);
        for ( m = 0; m < nMints; m++ )
        {
            uTruthPerm[0] = Map_CanonComputePhase( uTruths, nVarsMax, uTruth[0], m );
            if ( uTruthRes[0] > uTruthPerm[0] )
            {
                uTruthRes[0] = uTruthPerm[0];
                nPhases      = 0;
                puPhases[nPhases++] = (unsigned char)m;
            }
            else if ( uTruthRes[0] == uTruthPerm[0] )
            {
                if ( nPhases < 4 ) // the max number of phases in Map_Super_t
                    puPhases[nPhases++] = (unsigned char)m;
            }
        }
        uTruthRes[1] = uTruthRes[0];
    }
    else
    {
        uTruthRes[0] = MAP_MASK(32);
        uTruthRes[1] = MAP_MASK(32);
        for ( m = 0; m < nMints; m++ )
        {
            Map_CanonComputePhase6( uTruths, nVarsMax, uTruth, m, uTruthPerm );
            if ( uTruthRes[1] > uTruthPerm[1] || (uTruthRes[1] == uTruthPerm[1] && uTruthRes[0] > uTruthPerm[0]) )
            {
                uTruthRes[0] = uTruthPerm[0];
                uTruthRes[1] = uTruthPerm[1];
                nPhases      = 0;
                puPhases[nPhases++] = (unsigned char)m;
            }
            else if ( uTruthRes[1] == uTruthPerm[1] && uTruthRes[0] == uTruthPerm[0] )
            {
                if ( nPhases < 4 ) // the max number of phases in Map_Super_t
                    puPhases[nPhases++] = (unsigned char)m;
            }
        }
    }
    assert( nPhases > 0 );
//    printf( "%d ", nPhases );
    return nPhases;
}

Here is the caller graph for this function:

Map_CreateTableGate2Super()

st__table * Map_CreateTableGate2Super ( Map_Man_t * pMan )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 613 of file mapperUtils.c.

{
    Map_Super_t * pSuper;
    st__table * tTable;
    int i, nInputs, v;
    tTable = st__init_table(strcmp, st__strhash);
    for ( i = 0; i < pMan->pSuperLib->nSupersAll; i++ )
    {
        pSuper = pMan->pSuperLib->ppSupers[i];
        if ( pSuper->nGates == 1 )
        {
            // skip different versions of the same root gate
            nInputs = Mio_GateReadPinNum(pSuper->pRoot);
            for ( v = 0; v < nInputs; v++ )
                if ( pSuper->pFanins[v]->Num != nInputs - 1 - v )
                    break;
            if ( v != nInputs )
                continue;
//            printf( "%s\n", Mio_GateReadName(pSuper->pRoot) );
            if ( st__insert( tTable, (char *)pSuper->pRoot, (char *)pSuper ) )
            {
                assert( 0 );
            }
        }
    }
    return tTable;
}

Here is the call graph for this function:

Map_CutAlloc()

Map_Cut_t * Map_CutAlloc ( Map_Man_t * p )

extern

DECLARATIONS ///.

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

FileName [mapperCutUtils.c]

PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]

Synopsis [Generic technology mapping engine.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 2.0. Started - June 1, 2004.]

Revision [

Id

mapperCutUtils.h,v 1.0 2003/09/08 00:00:00 alanmi Exp

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

Synopsis [Allocates the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mapperCutUtils.c.

{
    Map_Cut_t * pCut;
    Map_Match_t * pMatch;
    pCut = (Map_Cut_t *)Extra_MmFixedEntryFetch( p->mmCuts );
    memset( pCut, 0, sizeof(Map_Cut_t) );
 
    pMatch = pCut->M;
    pMatch->AreaFlow       = MAP_FLOAT_LARGE; // unassigned
    pMatch->tArrive.Rise   = MAP_FLOAT_LARGE; // unassigned
    pMatch->tArrive.Fall   = MAP_FLOAT_LARGE; // unassigned
    pMatch->tArrive.Worst  = MAP_FLOAT_LARGE; // unassigned
 
    pMatch = pCut->M + 1;
    pMatch->AreaFlow       = MAP_FLOAT_LARGE; // unassigned
    pMatch->tArrive.Rise   = MAP_FLOAT_LARGE; // unassigned
    pMatch->tArrive.Fall   = MAP_FLOAT_LARGE; // unassigned
    pMatch->tArrive.Worst  = MAP_FLOAT_LARGE; // unassigned
    return pCut;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_CutCreateFromNode()

void Map_CutCreateFromNode ( Map_Man_t * p, Map_Super_t * pSuper, int iRoot, unsigned uPhaseRoot, int * pLeaves, int nLeaves, unsigned uPhaseLeaves )

extern

Map_CutInternalNodes()

Vec_Ptr_t * Map_CutInternalNodes ( Map_Node_t * pObj, Map_Cut_t * pCut )

extern

Definition at line 242 of file mapperCutUtils.c.

{
  Vec_Ptr_t * vAnds = Vec_PtrAlloc( 4 );
  Map_Node_t * pTemp; int i;
  pObj->p->nTravIds++;
  for ( i = 0; i < pCut->nLeaves; i++ )
    pCut->ppLeaves[i]->TravId = pObj->p->nTravIds;
  Map_CutInternalNodes_rec( pObj, vAnds );
  if ( 0 )
  {
    printf( "Leaves:\n" );
    for ( i = 0; i < pCut->nLeaves; i++ )
      printf( " %d", pCut->ppLeaves[i]->Num );
    printf( "\n" );
    printf( "Nodes:\n" );
    Vec_PtrForEachEntry( Map_Node_t *, vAnds, pTemp, i )
      printf( "%d = %s%d & %s%d\n", pTemp->Num, 
                                    Map_IsComplement(pTemp->p1) ? "~" : " ", Map_Regular(pTemp->p1)->Num, 
                                    Map_IsComplement(pTemp->p2) ? "~" : " ", Map_Regular(pTemp->p2)->Num );
    printf( "\n" );
  }
  return vAnds;
}

Here is the call graph for this function:

Map_CutReadLeaves()

Map_Node_t ** Map_CutReadLeaves ( Map_Cut_t * p )

extern

Definition at line 141 of file mapperCreate.c.

{ return p->ppLeaves; }

Map_CutReadLeavesNum()

int Map_CutReadLeavesNum ( Map_Cut_t * p )

extern

Definition at line 140 of file mapperCreate.c.

{ return p->nLeaves;  }

Map_CutReadNext()

Map_Cut_t * Map_CutReadNext ( Map_Cut_t * p )

extern

Definition at line 145 of file mapperCreate.c.

{ return p->pNext;          }

Map_CutReadPhase0()

unsigned Map_CutReadPhase0 ( Map_Cut_t * p )

extern

Definition at line 143 of file mapperCreate.c.

{ return p->M[0].uPhaseBest;}

Map_CutReadPhase1()

unsigned Map_CutReadPhase1 ( Map_Cut_t * p )

extern

Definition at line 144 of file mapperCreate.c.

{ return p->M[1].uPhaseBest;}

Map_CutReadPhaseBest()

unsigned Map_CutReadPhaseBest ( Map_Cut_t * p, int fPhase )

extern

Definition at line 142 of file mapperCreate.c.

{ return p->M[fPhase].uPhaseBest;}

Map_CutReadSuper0()

Map_Super_t * Map_CutReadSuper0 ( Map_Cut_t * p )

extern

Definition at line 138 of file mapperCreate.c.

{ return p->M[0].pSuperBest;}

Map_CutReadSuper1()

Map_Super_t * Map_CutReadSuper1 ( Map_Cut_t * p )

extern

Definition at line 139 of file mapperCreate.c.

{ return p->M[1].pSuperBest;}

Map_CutReadSuperBest()

Map_Super_t * Map_CutReadSuperBest ( Map_Cut_t * p, int fPhase )

extern

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

Synopsis [Reads parameters from the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 137 of file mapperCreate.c.

{ return p->M[fPhase].pSuperBest;}

Map_LibraryReadFormulaStep()

char * Map_LibraryReadFormulaStep ( char * pFormula, char * pStrings[], int * pnStrings )

extern

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

Synopsis [Performs one step of parsing the formula into parts.]

Description [This function will eventually be replaced when the tree-supergate library representation will become standard.]

SideEffects []

SeeAlso []

Definition at line 256 of file mapperSuper.c.

{
    char * pName, * pPar1, * pPar2, * pCur;
    int nStrings, CountPars;
 
    // skip leading spaces
    for ( pName = pFormula; *pName && *pName == ' '; pName++ );
    assert( *pName );
    // find the first opening parenthesis
    for ( pPar1 = pName; *pPar1 && *pPar1 != '('; pPar1++ );
    if ( *pPar1 == 0 )
    {
        *pnStrings = 0;
        return pName;
    }
    // overwrite it with space
    assert( *pPar1 == '(' );
    *pPar1 = 0;
    // find the corresponding closing parenthesis
    for ( CountPars = 1, pPar2 = pPar1 + 1; *pPar2 && CountPars; pPar2++ )
        if ( *pPar2 == '(' )
            CountPars++;
        else if ( *pPar2 == ')' )
            CountPars--;
    pPar2--;
    assert( CountPars == 0 );
    // overwrite it with space
    assert( *pPar2 == ')' );
    *pPar2 = 0;
    // save the intervals between the commas
    nStrings = 0;
    pCur = pPar1 + 1;
    while ( 1 )
    {
        // save the current string
        pStrings[ nStrings++ ] = pCur;
        // find the beginning of the next string
        for ( CountPars = 0; *pCur && (CountPars || *pCur != ','); pCur++ )
            if ( *pCur == '(' )
                CountPars++;
            else if ( *pCur == ')' )
                CountPars--;
        if ( *pCur == 0 )
            break;
        assert( *pCur == ',' );
        *pCur = 0;
        pCur++;
    }
    // save the results and return
    *pnStrings = nStrings;
    return pName;
}

Map_ManCheckConsistency()

int Map_ManCheckConsistency ( Map_Man_t * p )

extern

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

Synopsis [Verify one useful property.]

Description [This procedure verifies one useful property. After the FRAIG construction with choice nodes is over, each primary node should have fanins that are primary nodes. The primary nodes is the one that does not have pNode->pRepr set to point to another node.]

SideEffects []

SeeAlso []

Definition at line 427 of file mapperUtils.c.

{
    Map_Node_t * pNode;
    Map_NodeVec_t * pVec;
    int i;
    pVec = Map_MappingDfs( p, 0 );
    for ( i = 0; i < pVec->nSize; i++ )
    {
        pNode = pVec->pArray[i];
        if ( Map_NodeIsVar(pNode) )
        {
            if ( pNode->pRepr )
                printf( "Primary input %d is a secondary node.\n", pNode->Num );
        }
        else if ( Map_NodeIsConst(pNode) )
        {
            if ( pNode->pRepr )
                printf( "Constant 1 %d is a secondary node.\n", pNode->Num );
        }
        else
        {
            if ( pNode->pRepr )
                printf( "Internal node %d is a secondary node.\n", pNode->Num );
            if ( Map_Regular(pNode->p1)->pRepr )
                printf( "Internal node %d has first fanin that is a secondary node.\n", pNode->Num );
            if ( Map_Regular(pNode->p2)->pRepr )
                printf( "Internal node %d has second fanin that is a secondary node.\n", pNode->Num );
        }
    }
    Map_NodeVecFree( pVec );
    return 1;
}

Here is the call graph for this function:

Map_ManCleanData()

void Map_ManCleanData ( Map_Man_t * p )

extern

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

Synopsis [Get the FRAIG node with phase.]

Description []

SideEffects []

SeeAlso []

Definition at line 652 of file mapperUtils.c.

{
    int i;
    for ( i = 0; i < p->vMapObjs->nSize; i++ )
        p->vMapObjs->pArray[i]->pData0 = p->vMapObjs->pArray[i]->pData1 = 0;
}

Here is the caller graph for this function:

Map_ManCreate()

Map_Man_t * Map_ManCreate ( int nInputs, int nOutputs, int fVerbose )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Create the mapping manager.]

Description [The number of inputs and outputs is assumed to be known is advance. It is much simpler to have them fixed upfront. When it comes to representing the object graph in the form of AIG, the resulting manager is similar to the regular AIG manager, except that it does not use reference counting (and therefore does not have garbage collections). It does have table resizing. The data structure is more flexible to represent additional information needed for mapping.]

SideEffects []

SeeAlso []

Definition at line 192 of file mapperCreate.c.

{
    Map_Man_t * p;
    int i;
 
    // derive the supergate library
    if ( Abc_FrameReadLibSuper() == NULL )
    {
        printf( "The supergate library is not specified. Use \"read_super\".\n" );
        return NULL;
    }
 
    // start the manager
    p = ABC_ALLOC( Map_Man_t, 1 );
    memset( p, 0, sizeof(Map_Man_t) );
    p->pSuperLib = (Map_SuperLib_t *)Abc_FrameReadLibSuper();
    p->nVarsMax  = p->pSuperLib->nVarsMax;
    p->fVerbose  = fVerbose;
    p->fEpsilon  = (float)0.001;
    assert( p->nVarsMax > 0 );
 
    if ( p->nVarsMax == 5 )
        Extra_Truth4VarN( &p->uCanons, &p->uPhases, &p->pCounters, 8 );
 
    // start various data structures
    Map_TableCreate( p );
    Map_MappingSetupTruthTables( p->uTruths );
    Map_MappingSetupTruthTablesLarge( p->uTruthsLarge );
//    printf( "Node = %d bytes. Cut = %d bytes. Super = %d bytes.\n", sizeof(Map_Node_t), sizeof(Map_Cut_t), sizeof(Map_Super_t) ); 
    p->mmNodes    = Extra_MmFixedStart( sizeof(Map_Node_t) );
    p->mmCuts     = Extra_MmFixedStart( sizeof(Map_Cut_t) );
 
    // make sure the constant node will get index -1
    p->nNodes = -1;
    // create the constant node
    p->pConst1    = Map_NodeCreate( p, NULL, NULL );
    p->vMapObjs   = Map_NodeVecAlloc( 100 );
    p->vMapBufs   = Map_NodeVecAlloc( 100 );
    p->vVisited   = Map_NodeVecAlloc( 100 );
 
    // create the PI nodes
    p->nInputs = nInputs;
    p->pInputs = ABC_ALLOC( Map_Node_t *, nInputs );
    for ( i = 0; i < nInputs; i++ )
        p->pInputs[i] = Map_NodeCreate( p, NULL, NULL );
 
    // create the place for the output nodes
    p->nOutputs = nOutputs;
    p->pOutputs = ABC_ALLOC( Map_Node_t *, nOutputs );
    memset( p->pOutputs, 0, sizeof(Map_Node_t *) * nOutputs );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_ManCreateAigIds()

void Map_ManCreateAigIds ( Map_Man_t * p, int nObjs )

extern

Definition at line 78 of file mapperCreate.c.

{ p->pAigNodeIDs = ABC_CALLOC( int, nObjs ); }   

Here is the caller graph for this function:

Map_ManCreateNodeDelays()

void Map_ManCreateNodeDelays ( Map_Man_t * p, int LogFan )

extern

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

Synopsis [Creates node delays.]

Description []

SideEffects []

SeeAlso []

Definition at line 293 of file mapperCreate.c.

{
    Map_Node_t * pNode;
    int k;
    assert( p->pNodeDelays == NULL );
    p->pNodeDelays = ABC_CALLOC( float, p->vMapObjs->nSize );
    for ( k = 0; k < p->vMapObjs->nSize; k++ )
    {
        pNode = p->vMapObjs->pArray[k];
        if ( pNode->nRefs == 0 )
            continue;
        p->pNodeDelays[k] = 0.014426 * LogFan * p->pSuperLib->tDelayInv.Worst * log( (double)pNode->nRefs ); // 1.4426 = 1/ln(2)
//        printf( "%d = %d (%.2f)  ", k, pNode->nRefs, p->pNodeDelays[k] );
    }
//    printf( "\n" );
}

Here is the caller graph for this function:

Map_ManFree()

void Map_ManFree ( Map_Man_t * p )

extern

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

Synopsis [Deallocates the mapping manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 256 of file mapperCreate.c.

{
//    int i;
//    for ( i = 0; i < p->vMapObjs->nSize; i++ )
//        Map_NodeVecFree( p->vMapObjs->pArray[i]->vFanouts );
//    Map_NodeVecFree( p->pConst1->vFanouts );
    Map_NodeVecFree( p->vMapObjs );
    Map_NodeVecFree( p->vMapBufs );
    Map_NodeVecFree( p->vVisited );
    if ( p->uCanons )   ABC_FREE( p->uCanons );
    if ( p->uPhases )   ABC_FREE( p->uPhases );
    if ( p->pCounters ) ABC_FREE( p->pCounters );
    Extra_MmFixedStop( p->mmNodes );
    Extra_MmFixedStop( p->mmCuts );
    ABC_FREE( p->pAigNodeIDs );
    ABC_FREE( p->pNodeDelays );
    ABC_FREE( p->pInputArrivals );
    ABC_FREE( p->pOutputRequireds );
    ABC_FREE( p->pInputs );
    ABC_FREE( p->pOutputs );
    ABC_FREE( p->pBins );
    ABC_FREE( p->ppOutputNames );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_ManPrintStatsToFile()

void Map_ManPrintStatsToFile ( char * pName, float Area, float Delay, abctime Time )

extern

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

Synopsis [Prints the mapping stats.]

Description []

SideEffects []

SeeAlso []

Definition at line 350 of file mapperCreate.c.

{
    FILE * pTable;
    pTable = fopen( "map_stats.txt", "a+" );
    fprintf( pTable, "%s ", pName );
    fprintf( pTable, "%4.2f ", Area );
    fprintf( pTable, "%4.2f ", Delay );
    fprintf( pTable, "%4.2f\n", (float)(Time)/(float)(CLOCKS_PER_SEC) );
    fclose( pTable );
}

Map_ManPrintTimeStats()

void Map_ManPrintTimeStats ( Map_Man_t * p )

extern

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

Synopsis [Deallocates the mapping manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 322 of file mapperCreate.c.

{
    printf( "N-canonical = %d. Matchings = %d.  Phases = %d.  ", p->nCanons, p->nMatches, p->nPhases );
    printf( "Choice nodes = %d. Choices = %d.\n", p->nChoiceNodes, p->nChoices );
    ABC_PRT( "ToMap", p->timeToMap );
    ABC_PRT( "Cuts ", p->timeCuts  );
    ABC_PRT( "Truth", p->timeTruth );
    ABC_PRT( "Match", p->timeMatch );
    ABC_PRT( "Area ", p->timeArea  );
    ABC_PRT( "Sweep", p->timeSweep );
    ABC_PRT( "ToNet", p->timeToNet );
    ABC_PRT( "TOTAL", p->timeTotal );
    if ( p->time1 ) { ABC_PRT( "time1", p->time1 ); }
    if ( p->time2 ) { ABC_PRT( "time2", p->time2 ); }
    if ( p->time3 ) { ABC_PRT( "time3", p->time3 ); }
}

Map_ManReadAreaFinal()

float Map_ManReadAreaFinal ( Map_Man_t * p )

extern

Definition at line 61 of file mapperCreate.c.

{ return p->AreaFinal;  }

Map_ManReadBufDriver()

Map_Node_t * Map_ManReadBufDriver ( Map_Man_t * p, int i )

extern

Definition at line 55 of file mapperCreate.c.

{ return Map_ManReadBufs(p)[i]->p1;           }

Here is the call graph for this function:

Here is the caller graph for this function:

Map_ManReadBufNum()

int Map_ManReadBufNum ( Map_Man_t * p )

extern

Definition at line 51 of file mapperCreate.c.

{ return Map_NodeVecReadSize(p->vMapBufs);   }

Here is the call graph for this function:

Here is the caller graph for this function:

Map_ManReadBufs()

Map_Node_t ** Map_ManReadBufs ( Map_Man_t * p )

extern

Definition at line 54 of file mapperCreate.c.

{ return Map_NodeVecReadArray(p->vMapBufs);  }

Here is the call graph for this function:

Here is the caller graph for this function:

Map_ManReadConst1()

Map_Node_t * Map_ManReadConst1 ( Map_Man_t * p )

extern

Definition at line 56 of file mapperCreate.c.

{ return p->pConst1;    }

Here is the caller graph for this function:

Map_ManReadFanoutViolations()

int Map_ManReadFanoutViolations ( Map_Man_t * p )

extern

Definition at line 70 of file mapperCreate.c.

{ return p->nFanoutViolations;   }  

Map_ManReadGenLib()

Mio_Library_t * Map_ManReadGenLib ( Map_Man_t * p )

extern

Definition at line 59 of file mapperCreate.c.

{ return p->pSuperLib->pGenlib; }

Map_ManReadInputArrivals()

Map_Time_t * Map_ManReadInputArrivals ( Map_Man_t * p )

extern

Definition at line 57 of file mapperCreate.c.

{ return p->pInputArrivals; }

Map_ManReadInputNum()

int Map_ManReadInputNum ( Map_Man_t * p )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Reads parameters from the mapping manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file mapperCreate.c.

{ return p->nInputs;    }

Map_ManReadInputs()

Map_Node_t ** Map_ManReadInputs ( Map_Man_t * p )

extern

Definition at line 52 of file mapperCreate.c.

{ return p->pInputs;    }

Here is the caller graph for this function:

Map_ManReadOutputNum()

int Map_ManReadOutputNum ( Map_Man_t * p )

extern

Definition at line 50 of file mapperCreate.c.

{ return p->nOutputs;   }

Map_ManReadOutputs()

Map_Node_t ** Map_ManReadOutputs ( Map_Man_t * p )

extern

Definition at line 53 of file mapperCreate.c.

{ return p->pOutputs;   }

Here is the caller graph for this function:

Map_ManReadPass()

int Map_ManReadPass ( Map_Man_t * p )

extern

Map_ManReadRequiredGlo()

float Map_ManReadRequiredGlo ( Map_Man_t * p )

extern

Definition at line 62 of file mapperCreate.c.

{ return p->fRequiredGlo; }

Map_ManReadVerbose()

int Map_ManReadVerbose ( Map_Man_t * p )

extern

Definition at line 60 of file mapperCreate.c.

{ return p->fVerbose;   }

Map_ManSetAreaRecovery()

void Map_ManSetAreaRecovery ( Map_Man_t * p, int fAreaRecovery )

extern

Definition at line 64 of file mapperCreate.c.

{ p->fAreaRecovery = fAreaRecovery;}

Here is the caller graph for this function:

Map_ManSetChoiceNodeNum()

void Map_ManSetChoiceNodeNum ( Map_Man_t * p, int nChoiceNodes )

extern

Definition at line 72 of file mapperCreate.c.

{ p->nChoiceNodes = nChoiceNodes; }  

Map_ManSetChoiceNum()

void Map_ManSetChoiceNum ( Map_Man_t * p, int nChoices )

extern

Definition at line 73 of file mapperCreate.c.

{ p->nChoices = nChoices;     }   

Map_ManSetDelayTarget()

void Map_ManSetDelayTarget ( Map_Man_t * p, float DelayTarget )

extern

Definition at line 65 of file mapperCreate.c.

{ p->DelayTarget = DelayTarget;}

Here is the caller graph for this function:

Map_ManSetFanoutViolations()

void Map_ManSetFanoutViolations ( Map_Man_t * p, int nVio )

extern

Definition at line 71 of file mapperCreate.c.

{ p->nFanoutViolations = nVio;   }  

Map_ManSetInputArrivals()

void Map_ManSetInputArrivals ( Map_Man_t * p, Map_Time_t * pArrivals )

extern

Definition at line 66 of file mapperCreate.c.

{ p->pInputArrivals = pArrivals;    }

Here is the caller graph for this function:

Map_ManSetNumIterations()

void Map_ManSetNumIterations ( Map_Man_t * p, int nNumIterations )

extern

Definition at line 69 of file mapperCreate.c.

{ p->nIterations = nIterations;     }

Map_ManSetObeyFanoutLimits()

void Map_ManSetObeyFanoutLimits ( Map_Man_t * p, int fObeyFanoutLimits )

extern

Definition at line 68 of file mapperCreate.c.

{ p->fObeyFanoutLimits = fObeyFanoutLimits;     }

Map_ManSetOutputNames()

void Map_ManSetOutputNames ( Map_Man_t * p, char ** ppNames )

extern

Definition at line 63 of file mapperCreate.c.

{ p->ppOutputNames = ppNames;}

Here is the caller graph for this function:

Map_ManSetOutputRequireds()

void Map_ManSetOutputRequireds ( Map_Man_t * p, Map_Time_t * pArrivals )

extern

Definition at line 67 of file mapperCreate.c.

{ p->pOutputRequireds = pRequireds; }

Here is the caller graph for this function:

Map_ManSetPass()

void Map_ManSetPass ( Map_Man_t * p, int nPass )

extern

Map_ManSetSkipFanout()

void Map_ManSetSkipFanout ( Map_Man_t * p, int fSkipFanout )

extern

Definition at line 76 of file mapperCreate.c.

{ p->fSkipFanout = fSkipFanout; }   

Here is the caller graph for this function:

Map_ManSetSwitching()

void Map_ManSetSwitching ( Map_Man_t * p, int fSwitching )

extern

Definition at line 75 of file mapperCreate.c.

{ p->fSwitching = fSwitching; }   

Here is the caller graph for this function:

Map_ManSetUseProfile()

void Map_ManSetUseProfile ( Map_Man_t * p )

extern

Definition at line 77 of file mapperCreate.c.

{ p->fUseProfile = 1;         }   

Here is the caller graph for this function:

Map_ManSetVerbose()

void Map_ManSetVerbose ( Map_Man_t * p, int fVerbose )

extern

Definition at line 74 of file mapperCreate.c.

{ p->fVerbose = fVerbose;     }   

Map_Mapping()

int Map_Mapping ( Map_Man_t * p )

extern

DECLARATIONS ///.

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

FileName [mapperCore.c]

PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]

Synopsis [Generic technology mapping engine.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 2.0. Started - June 1, 2004.]

Revision [

Id

mapperCore.c,v 1.7 2004/10/01 23:41:04 satrajit Exp

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

Synopsis [Performs technology mapping for the given object graph.]

Description [The object graph is stored in the mapping manager. First, the AND nodes that fanout into POs are collected in the DFS order. Two preprocessing steps are performed: the k-feasible cuts are computed for each node and the truth tables are computed for each cut. Next, the delay-optimal matches are assigned for each node, followed by several iterations of area recoveryd: using area flow (global optimization) and using exact area at a node (local optimization).]

SideEffects []

SeeAlso []

Definition at line 50 of file mapperCore.c.

{
    int fShowSwitching         = 0;
    int fUseAreaFlow           = 1;
    int fUseExactArea          = !p->fSwitching;
    int fUseExactAreaWithPhase = !p->fSwitching;
    abctime clk;

    // perform pre-mapping computations
    if ( p->fVerbose )
        Map_MappingReportChoices( p ); 
    Map_MappingSetChoiceLevels( p ); // should always be called before mapping!
//    return 1;
 
    // compute the cuts of nodes in the DFS order
    clk = Abc_Clock();
    Map_MappingCuts( p );
    p->timeCuts = Abc_Clock() - clk;
    // derive the truth tables 
    clk = Abc_Clock();
    Map_MappingTruths( p );
    p->timeTruth = Abc_Clock() - clk;
//ABC_PRT( "Truths", Abc_Clock() - clk );

    // compute the minimum-delay mapping
    clk = Abc_Clock();
    p->fMappingMode = 0;
    if ( !Map_MappingMatches( p ) )
        return 0;
    p->timeMatch = Abc_Clock() - clk;
    // compute the references and collect the nodes used in the mapping
    Map_MappingSetRefs( p );
    p->AreaBase = Map_MappingGetArea( p );
if ( p->fVerbose )
{
printf( "Delay    : %s = %8.2f  Flow = %11.1f  Area = %11.1f  %4.1f %%   ", 
                    fShowSwitching? "Switch" : "Delay", 
                    fShowSwitching? Map_MappingGetSwitching(p) : p->fRequiredGlo, 
                    Map_MappingGetAreaFlow(p), p->AreaBase, 0.0 );
ABC_PRT( "Time", p->timeMatch );
}
 
    if ( !p->fAreaRecovery )
    {
        if ( p->fVerbose )
            Map_MappingPrintOutputArrivals( p );
        return 1;
    }

    // perform area recovery using area flow
    clk = Abc_Clock();
    if ( fUseAreaFlow )
    {
        // compute the required times
        Map_TimeComputeRequiredGlobal( p );
        // recover area flow
        p->fMappingMode = 1;
        Map_MappingMatches( p );
        // compute the references and collect the nodes used in the mapping
        Map_MappingSetRefs( p );
        p->AreaFinal = Map_MappingGetArea( p );
if ( p->fVerbose )
{
printf( "AreaFlow : %s = %8.2f  Flow = %11.1f  Area = %11.1f  %4.1f %%   ", 
                    fShowSwitching? "Switch" : "Delay", 
                    fShowSwitching? Map_MappingGetSwitching(p) : p->fRequiredGlo, 
                    Map_MappingGetAreaFlow(p), p->AreaFinal, 
                    100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase );
ABC_PRT( "Time", Abc_Clock() - clk );
}
    }
    p->timeArea += Abc_Clock() - clk;

    // perform area recovery using exact area
    clk = Abc_Clock();
    if ( fUseExactArea )
    {
        // compute the required times
        Map_TimeComputeRequiredGlobal( p );
        // recover area
        p->fMappingMode = 2;
        Map_MappingMatches( p );
        // compute the references and collect the nodes used in the mapping
        Map_MappingSetRefs( p );
        p->AreaFinal = Map_MappingGetArea( p );
if ( p->fVerbose )
{
printf( "Area     : %s = %8.2f  Flow = %11.1f  Area = %11.1f  %4.1f %%   ", 
                    fShowSwitching? "Switch" : "Delay", 
                    fShowSwitching? Map_MappingGetSwitching(p) : p->fRequiredGlo, 
                    0.0, p->AreaFinal, 
                    100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase );
ABC_PRT( "Time", Abc_Clock() - clk );
}
    }
    p->timeArea += Abc_Clock() - clk;

    // perform area recovery using exact area
    clk = Abc_Clock();
    if ( fUseExactAreaWithPhase )
    {
        // compute the required times
        Map_TimeComputeRequiredGlobal( p );
        // recover area
        p->fMappingMode = 3;
        Map_MappingMatches( p );
        // compute the references and collect the nodes used in the mapping
        Map_MappingSetRefs( p );
        p->AreaFinal = Map_MappingGetArea( p );
if ( p->fVerbose )
{
printf( "Area     : %s = %8.2f  Flow = %11.1f  Area = %11.1f  %4.1f %%   ", 
                    fShowSwitching? "Switch" : "Delay", 
                    fShowSwitching? Map_MappingGetSwitching(p) : p->fRequiredGlo, 
                    0.0, p->AreaFinal, 
                    100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase );
ABC_PRT( "Time", Abc_Clock() - clk );
}
    }
    p->timeArea += Abc_Clock() - clk;

    // perform area recovery using exact area
    clk = Abc_Clock();
    if ( p->fSwitching )
    {
        // compute the required times
        Map_TimeComputeRequiredGlobal( p );
        // recover switching activity
        p->fMappingMode = 4;
        Map_MappingMatches( p );
        // compute the references and collect the nodes used in the mapping
        Map_MappingSetRefs( p );
        p->AreaFinal = Map_MappingGetArea( p );
if ( p->fVerbose )
{
printf( "Switching: %s = %8.2f  Flow = %11.1f  Area = %11.1f  %4.1f %%   ", 
                    fShowSwitching? "Switch" : "Delay", 
                    fShowSwitching? Map_MappingGetSwitching(p) : p->fRequiredGlo, 
                    0.0, p->AreaFinal, 
                    100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase );
ABC_PRT( "Time", Abc_Clock() - clk );
}
 
        // compute the required times
        Map_TimeComputeRequiredGlobal( p );
        // recover switching activity
        p->fMappingMode = 4;
        Map_MappingMatches( p );
        // compute the references and collect the nodes used in the mapping
        Map_MappingSetRefs( p );
        p->AreaFinal = Map_MappingGetArea( p );
if ( p->fVerbose )
{
printf( "Switching: %s = %8.2f  Flow = %11.1f  Area = %11.1f  %4.1f %%   ", 
                    fShowSwitching? "Switch" : "Delay", 
                    fShowSwitching? Map_MappingGetSwitching(p) : p->fRequiredGlo, 
                    0.0, p->AreaFinal, 
                    100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase );
ABC_PRT( "Time", Abc_Clock() - clk );
}
    }
    p->timeArea += Abc_Clock() - clk;
 
    // print the arrival times of the latest outputs
    if ( p->fVerbose )
        Map_MappingPrintOutputArrivals( p );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_MappingSetupTruthTables()

void Map_MappingSetupTruthTables ( unsigned uTruths[][2] )

extern

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

Synopsis [Sets up the truth tables.]

Description []

SideEffects []

SeeAlso []

Definition at line 335 of file mapperUtils.c.

{
    int m, v;
    // set up the truth tables
    for ( m = 0; m < 32; m++ )
        for ( v = 0; v < 5; v++ )
            if ( m & (1 << v) )
                uTruths[v][0] |= (1 << m);
    // make adjustments for the case of 6 variables
    for ( v = 0; v < 5; v++ )
        uTruths[v][1] = uTruths[v][0];
    uTruths[5][0] = 0;
    uTruths[5][1] = MAP_FULL;
}

Here is the caller graph for this function:

Map_MappingSetupTruthTablesLarge()

void Map_MappingSetupTruthTablesLarge ( unsigned uTruths[][32] )

extern

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

Synopsis [Sets up the truth tables.]

Description []

SideEffects []

SeeAlso []

Definition at line 361 of file mapperUtils.c.

{
    int m, v;
    // clean everything
    for ( m = 0; m < 32; m++ )
        for ( v = 0; v < 10; v++ )
            uTruths[v][m] = 0;
    // set up the truth tables
    for ( m = 0; m < 32; m++ )
        for ( v = 0; v < 5; v++ )
            if ( m & (1 << v) )
            {
                uTruths[v][0] |= (1 << m);
                uTruths[v+5][m] = MAP_FULL;
            }
    // extend this info for the rest of the first 5 variables
    for ( m = 0; m < 32; m++ )
        for ( v = 0; v < 5; v++ )
            uTruths[v][m] = uTruths[v][0];
/*
    // verify
    for ( m = 0; m < 1024; m++, printf("\n") )
        for ( v = 0; v < 10; v++ )
            if ( Map_InfoReadVar( uTruths[v], m ) )
                printf( "1" );
            else
                printf( "0" );
*/
}

Here is the caller graph for this function:

Map_NetworkSweep()

void Map_NetworkSweep ( Abc_Ntk_t * pNet )

extern

Map_NodeAnd()

Map_Node_t * Map_NodeAnd ( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2 )

extern

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

Synopsis [Looks up the AND2 node in the unique table.]

Description [This procedure implements one-level hashing. All the nodes are hashed by their children. If the node with the same children was already created, it is returned by the call to this procedure. If it does not exist, this procedure creates a new node with these children. ]

SideEffects []

SeeAlso []

Definition at line 456 of file mapperCreate.c.

{
    Map_Node_t * pEnt;
    unsigned Key;
 
    if ( p1 == p2 )
        return p1;
    if ( p1 == Map_Not(p2) )
        return Map_Not(pMan->pConst1);
    if ( Map_NodeIsConst(p1) )
    {
        if ( p1 == pMan->pConst1 )
            return p2;
        return Map_Not(pMan->pConst1);
    }
    if ( Map_NodeIsConst(p2) )
    {
        if ( p2 == pMan->pConst1 )
            return p1;
        return Map_Not(pMan->pConst1);
    }
 
    if ( Map_Regular(p1)->Num > Map_Regular(p2)->Num )
        pEnt = p1, p1 = p2, p2 = pEnt;
 
    Key = Map_HashKey2( p1, p2, pMan->nBins );
    for ( pEnt = pMan->pBins[Key]; pEnt; pEnt = pEnt->pNext )
        if ( pEnt->p1 == p1 && pEnt->p2 == p2 )
            return pEnt;
    // resize the table
    if ( pMan->nNodes >= 2 * pMan->nBins )
    {
        Map_TableResize( pMan );
        Key = Map_HashKey2( p1, p2, pMan->nBins );
    }
    // create the new node
    pEnt = Map_NodeCreate( pMan, p1, p2 );
    // add the node to the corresponding linked list in the table
    pEnt->pNext = pMan->pBins[Key];
    pMan->pBins[Key] = pEnt;
    return pEnt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_NodeBuf()

Map_Node_t * Map_NodeBuf ( Map_Man_t * p, Map_Node_t * p1 )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 561 of file mapperCreate.c.

{
    Map_Node_t * pNode = Map_NodeCreate( p, p1, NULL );
    Map_NodeVecPush( p->vMapBufs, pNode );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_NodeComparePhase()

int Map_NodeComparePhase ( Map_Node_t * p1, Map_Node_t * p2 )

extern

Definition at line 124 of file mapperCreate.c.

{ assert( !Map_IsComplement(p1) ); assert( !Map_IsComplement(p2) ); return p1->fInv ^ p2->fInv; }

Map_NodeCreate()

Map_Node_t * Map_NodeCreate ( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 )

extern

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

Synopsis [Creates a new node.]

Description [This procedure should be called to create the constant node and the PI nodes first.]

SideEffects []

SeeAlso []

Definition at line 373 of file mapperCreate.c.

{
    Map_Node_t * pNode;
    // create the node
    pNode = (Map_Node_t *)Extra_MmFixedEntryFetch( p->mmNodes );
    memset( pNode, 0, sizeof(Map_Node_t) );
    pNode->tRequired[0].Rise = pNode->tRequired[0].Fall = pNode->tRequired[0].Worst = MAP_FLOAT_LARGE;
    pNode->tRequired[1].Rise = pNode->tRequired[1].Fall = pNode->tRequired[1].Worst = MAP_FLOAT_LARGE;
    pNode->p1  = p1; 
    pNode->p2  = p2;
    pNode->p = p;
    // set the number of this node
    pNode->Num = p->nNodes++;
    // place to store the fanouts
//    pNode->vFanouts = Map_NodeVecAlloc( 5 );
    // store this node in the internal array
    if ( pNode->Num >= 0 )
        Map_NodeVecPush( p->vMapObjs, pNode );
    else
        pNode->fInv = 1;
    // set the level of this node
    if ( p1 ) 
    {
#ifdef MAP_ALLOCATE_FANOUT
        // create the fanout info
        Map_NodeAddFaninFanout( Map_Regular(p1), pNode );
        if ( p2 )
        Map_NodeAddFaninFanout( Map_Regular(p2), pNode );
#endif
 
        if ( p2 )
        {
            pNode->Level = 1 + MAP_MAX(Map_Regular(pNode->p1)->Level, Map_Regular(pNode->p2)->Level);
            pNode->fInv  = Map_NodeIsSimComplement(p1) & Map_NodeIsSimComplement(p2);
        }
        else
        {
            pNode->Level = Map_Regular(pNode->p1)->Level;
            pNode->fInv  = Map_NodeIsSimComplement(p1);
        }
    }
    // reference the inputs (will be used to compute the number of fanouts)
    if ( p1 ) Map_NodeRef(p1);
    if ( p2 ) Map_NodeRef(p2);
 
    pNode->nRefEst[0] = pNode->nRefEst[1] = -1;
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_NodeIsAnd()

int Map_NodeIsAnd ( Map_Node_t * p )

extern

Definition at line 123 of file mapperCreate.c.

{  return (Map_Regular(p))->p1 != NULL && (Map_Regular(p))->p2 != NULL;  }

Here is the caller graph for this function:

Map_NodeIsBuf()

int Map_NodeIsBuf ( Map_Node_t * p )

extern

Definition at line 122 of file mapperCreate.c.

{  return (Map_Regular(p))->p1 != NULL && (Map_Regular(p))->p2 == NULL;  }

Here is the caller graph for this function:

Map_NodeIsConst()

int Map_NodeIsConst ( Map_Node_t * p )

extern

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

Synopsis [Checks the type of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 120 of file mapperCreate.c.

{  return (Map_Regular(p))->Num == -1;    }

Here is the caller graph for this function:

Map_NodeIsVar()

int Map_NodeIsVar ( Map_Node_t * p )

extern

Definition at line 121 of file mapperCreate.c.

{  return (Map_Regular(p))->p1 == NULL && (Map_Regular(p))->Num >= 0; }

Here is the caller graph for this function:

Map_NodeReadAigId()

int Map_NodeReadAigId ( Map_Node_t * p )

extern

Definition at line 95 of file mapperCreate.c.

{ return p->p->pAigNodeIDs[p->Num]; }

Map_NodeReadCutBest()

Map_Cut_t * Map_NodeReadCutBest ( Map_Node_t * p, int fPhase )

extern

Definition at line 97 of file mapperCreate.c.

{ return p->pCutBest[fPhase];   }

Map_NodeReadCuts()

Map_Cut_t * Map_NodeReadCuts ( Map_Node_t * p )

extern

Definition at line 96 of file mapperCreate.c.

{ return p->pCuts;              }

Map_NodeReadData()

char * Map_NodeReadData ( Map_Node_t * p, int fPhase )

extern

Definition at line 92 of file mapperCreate.c.

{ return fPhase? p->pData1 : p->pData0;  }

Map_NodeReadLevel()

int Map_NodeReadLevel ( Map_Node_t * p )

extern

Definition at line 94 of file mapperCreate.c.

{ return Map_Regular(p)->Level; }

Map_NodeReadMan()

Map_Man_t * Map_NodeReadMan ( Map_Node_t * p )

extern

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

Synopsis [Reads parameters from the mapping node.]

Description []

SideEffects []

SeeAlso []

Definition at line 91 of file mapperCreate.c.

{ return p->p;                  }

Map_NodeReadNum()

int Map_NodeReadNum ( Map_Node_t * p )

extern

Definition at line 93 of file mapperCreate.c.

{ return p->Num;                }

Map_NodeReadOne()

Map_Node_t * Map_NodeReadOne ( Map_Node_t * p )

extern

Definition at line 98 of file mapperCreate.c.

{ return p->p1;                 }

Map_NodeReadTwo()

Map_Node_t * Map_NodeReadTwo ( Map_Node_t * p )

extern

Definition at line 99 of file mapperCreate.c.

{ return p->p2;                 }

Map_NodeSetAigId()

void Map_NodeSetAigId ( Map_Node_t * p, int Id )

extern

Definition at line 104 of file mapperCreate.c.

{ p->p->pAigNodeIDs[p->Num] = Id; }

Here is the caller graph for this function:

Map_NodeSetChoice()

void Map_NodeSetChoice ( Map_Man_t * pMan, Map_Node_t * pNodeOld, Map_Node_t * pNodeNew )

extern

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

Synopsis [Sets the node to be equivalent to the given one.]

Description [This procedure is a work-around for the equivalence check. Does not verify the equivalence. Use at the user's risk.]

SideEffects []

SeeAlso []

Definition at line 580 of file mapperCreate.c.

{
    pNodeNew->pNextE = pNodeOld->pNextE;
    pNodeOld->pNextE = pNodeNew;
    pNodeNew->pRepr  = pNodeOld;
}

Map_NodeSetData()

void Map_NodeSetData ( Map_Node_t * p, int fPhase, char * pData )

extern

Definition at line 100 of file mapperCreate.c.

{ if (fPhase) p->pData1 = pData; else p->pData0 = pData; }

Here is the caller graph for this function:

Map_NodeSetNextE()

void Map_NodeSetNextE ( Map_Node_t * p, Map_Node_t * pNextE )

extern

Definition at line 101 of file mapperCreate.c.

{ p->pNextE = pNextE;       }

Here is the caller graph for this function:

Map_NodeSetRepr()

void Map_NodeSetRepr ( Map_Node_t * p, Map_Node_t * pRepr )

extern

Definition at line 102 of file mapperCreate.c.

{ p->pRepr = pRepr;         }

Here is the caller graph for this function:

Map_NodeSetSwitching()

void Map_NodeSetSwitching ( Map_Node_t * p, float Switching )

extern

Definition at line 103 of file mapperCreate.c.

{ p->Switching = Switching; }

Here is the caller graph for this function:

Map_SuperLibDeriveFromGenlib()

int Map_SuperLibDeriveFromGenlib ( Mio_Library_t * pLib, int fVerbose )

extern

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

Synopsis [Derives the library from the genlib library.]

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file mapperLib.c.

{
    Map_SuperLib_t * pLibSuper;
    Vec_Str_t * vStr;
    char * pFileName;
    if ( pLib == NULL )
        return 0;
 
    // compute supergates
    vStr = Super_PrecomputeStr( pLib, 5, 1, 100000000, 10000000, 10000000, 100, 1, 0 );
    if ( vStr == NULL )
        return 0;
 
    // create supergate library
    pFileName = Extra_FileNameGenericAppend( Mio_LibraryReadName(pLib), ".super" );
    pLibSuper = Map_SuperLibCreate( pLib, vStr, pFileName, NULL, 1, 0 );
    Vec_StrFree( vStr );
 
    // replace the library
    Map_SuperLibFree( (Map_SuperLib_t *)Abc_FrameReadLibSuper() );
    Abc_FrameSetLibSuper( pLibSuper );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_SuperLibFree()

void Map_SuperLibFree ( Map_SuperLib_t * p )

extern

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

Synopsis [Deallocates the supergate library.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file mapperLib.c.

{
    if ( p == NULL ) return;
    if ( p->pGenlib )
    {
        if ( p->pGenlib != Abc_FrameReadLibGen() )
            Mio_LibraryDelete( p->pGenlib );
        p->pGenlib = NULL;
    }
    if ( p->tTableC )
        Map_SuperTableFree( p->tTableC );
    if ( p->tTable )
        Map_SuperTableFree( p->tTable );
    Extra_MmFixedStop( p->mmSupers );
    Extra_MmFixedStop( p->mmEntries );
    Extra_MmFlexStop( p->mmForms );
    ABC_FREE( p->ppSupers );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Map_SuperLibReadAreaInv()

float Map_SuperLibReadAreaInv ( Map_SuperLib_t * p )

extern

Definition at line 169 of file mapperCreate.c.

{  return p->AreaInv;  }

Map_SuperLibReadDelayInv()

Map_Time_t Map_SuperLibReadDelayInv ( Map_SuperLib_t * p )

extern

Definition at line 170 of file mapperCreate.c.

{  return p->tDelayInv;}

Map_SuperLibReadGenLib()

Mio_Library_t * Map_SuperLibReadGenLib ( Map_SuperLib_t * p )

extern

Definition at line 168 of file mapperCreate.c.

{  return p->pGenlib;  }

Map_SuperLibReadVarsMax()

int Map_SuperLibReadVarsMax ( Map_SuperLib_t * p )

extern

Definition at line 171 of file mapperCreate.c.

{  return p->nVarsMax; }

Map_SuperReadFaninNum()

int Map_SuperReadFaninNum ( Map_Super_t * p )

extern

Definition at line 162 of file mapperCreate.c.

{  return p->nFanins;  }

Here is the caller graph for this function:

Map_SuperReadFanins()

Map_Super_t ** Map_SuperReadFanins ( Map_Super_t * p )

extern

Definition at line 161 of file mapperCreate.c.

{  return p->pFanins;  }

Here is the caller graph for this function:

Map_SuperReadFanoutLimit()

int Map_SuperReadFanoutLimit ( Map_Super_t * p )

extern

Definition at line 166 of file mapperCreate.c.

{  return p->nFanLimit;}

Map_SuperReadFormula()

char * Map_SuperReadFormula ( Map_Super_t * p )

extern

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

Synopsis [Reads parameters from the supergate.]

Description []

SideEffects []

SeeAlso []

Definition at line 158 of file mapperCreate.c.

{  return p->pFormula; }

Map_SuperReadNext()

Map_Super_t * Map_SuperReadNext ( Map_Super_t * p )

extern

Definition at line 163 of file mapperCreate.c.

{  return p->pNext;    }

Map_SuperReadNum()

int Map_SuperReadNum ( Map_Super_t * p )

extern

Definition at line 160 of file mapperCreate.c.

{  return p->Num;      }

Here is the caller graph for this function:

Map_SuperReadNumPhases()

int Map_SuperReadNumPhases ( Map_Super_t * p )

extern

Definition at line 164 of file mapperCreate.c.

{  return p->nPhases;  }

Map_SuperReadPhases()

unsigned char * Map_SuperReadPhases ( Map_Super_t * p )

extern

Definition at line 165 of file mapperCreate.c.

{  return p->uPhases;  }

Map_SuperReadRoot()

Mio_Gate_t * Map_SuperReadRoot ( Map_Super_t * p )

extern

Definition at line 159 of file mapperCreate.c.

{  return p->pRoot;    }

Here is the caller graph for this function:

Map_SuperTableLookupC()

Map_Super_t * Map_SuperTableLookupC ( Map_SuperLib_t * p, unsigned uTruth[] )

extern

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

Synopsis [Looks up an entry in the library.]

Description [This function looks up the function, given by its truth table, and return two things: (1) the linked list of supergates, which can implement the functions of this N-class; (2) the phase, which should be applied to the given function, in order to derive the canonical form of this N-class.]

SideEffects []

SeeAlso []

Definition at line 183 of file mapperTable.c.

{
    Map_HashEntry_t * pEnt;
    unsigned Key;
    Key = MAP_TABLE_HASH( uTruth[0], uTruth[1], p->tTableC->nBins );
    for ( pEnt = p->tTableC->pBins[Key]; pEnt; pEnt = pEnt->pNext )
        if ( pEnt->uTruth[0] == uTruth[0] && pEnt->uTruth[1] == uTruth[1] )
            return pEnt->pGates;
    return NULL;
}