mapperCreate.c File Reference

#include "mapperInt.h"

Go to the source code of this file.

Functions
static ABC_NAMESPACE_IMPL_START void	Map_TableCreate (Map_Man_t *p)
	DECLARATIONS ///. More...
static void	Map_TableResize (Map_Man_t *p)
static unsigned	Map_HashKey2 (Map_Node_t *p0, Map_Node_t *p1, int TableSize)
int	Map_ManReadInputNum (Map_Man_t *p)
	FUNCTION DEFINITIONS ///. More...
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)
Map_Time_t *	Map_ManReadOutputRequireds (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 *pRequireds)
void	Map_ManSetObeyFanoutLimits (Map_Man_t *p, int fObeyFanoutLimits)
void	Map_ManSetNumIterations (Map_Man_t *p, int nIterations)
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)
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)
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)
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_Man_t *	Map_ManCreate (int nInputs, int nOutputs, int fVerbose)
	FUNCTION DEFINITIONS ///. More...
void	Map_ManFree (Map_Man_t *p)
void	Map_ManCreateNodeDelays (Map_Man_t *p, int LogFan)
void	Map_ManPrintTimeStats (Map_Man_t *p)
void	Map_ManPrintStatsToFile (char *pName, float Area, float Delay, abctime Time)
Map_Node_t *	Map_NodeCreate (Map_Man_t *p, Map_Node_t *p1, Map_Node_t *p2)
Map_Node_t *	Map_NodeAnd (Map_Man_t *pMan, 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)

Function Documentation

Map_Node_t** Map_CutReadLeaves

(

Map_Cut_t *

p

)

Definition at line 133 of file mapperCreate.c.

{ return p->ppLeaves; }

int Map_CutReadLeavesNum

(

Map_Cut_t *

p

)

Definition at line 132 of file mapperCreate.c.

{ return p->nLeaves;  }

Map_Cut_t* Map_CutReadNext

(

Map_Cut_t *

p

)

Definition at line 137 of file mapperCreate.c.

{ return p->pNext;          }

unsigned Map_CutReadPhase0

(

Map_Cut_t *

p

)

Definition at line 135 of file mapperCreate.c.

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

unsigned Map_CutReadPhase1

(

Map_Cut_t *

p

)

Definition at line 136 of file mapperCreate.c.

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

unsigned Map_CutReadPhaseBest	(	Map_Cut_t *	p,
		int	fPhase
	)

Definition at line 134 of file mapperCreate.c.

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

Map_Super_t* Map_CutReadSuper0

(

Map_Cut_t *

p

)

Definition at line 130 of file mapperCreate.c.

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

Map_Super_t* Map_CutReadSuper1

(

Map_Cut_t *

p

)

Definition at line 131 of file mapperCreate.c.

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

Map_Super_t* Map_CutReadSuperBest	(	Map_Cut_t *	p,
		int	fPhase
	)

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

Synopsis [Reads parameters from the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 129 of file mapperCreate.c.

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

static unsigned Map_HashKey2 ( Map_Node_t *  p0, Map_Node_t *  p1, int  TableSize  )

inlinestatic

Definition at line 32 of file mapperCreate.c.

{ return (unsigned)(((ABC_PTRUINT_T)(p0) + (ABC_PTRUINT_T)(p1) * 12582917) % TableSize); }

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

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

void Map_ManCreateNodeDelays	(	Map_Man_t *	p,
		int	LogFan
	)

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

Synopsis [Creates node delays.]

Description []

SideEffects []

SeeAlso []

Definition at line 284 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" );
}

void Map_ManFree

(

Map_Man_t *

p

)

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

Synopsis [Deallocates the mapping manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 248 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->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 );
}

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

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

Synopsis [Prints the mapping stats.]

Description []

SideEffects []

SeeAlso []

Definition at line 341 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 );
}

void Map_ManPrintTimeStats

(

Map_Man_t *

p

)

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

Synopsis [Deallocates the mapping manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 313 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 ); }
}

float Map_ManReadAreaFinal

(

Map_Man_t *

p

)

Definition at line 61 of file mapperCreate.c.

{ return p->AreaFinal;  }

Map_Node_t* Map_ManReadBufDriver	(	Map_Man_t *	p,
		int	i
	)

Definition at line 55 of file mapperCreate.c.

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

int Map_ManReadBufNum

(

Map_Man_t *

p

)

Definition at line 51 of file mapperCreate.c.

{ return Map_NodeVecReadSize(p->vMapBufs);   }

Map_Node_t** Map_ManReadBufs

(

Map_Man_t *

p

)

Definition at line 54 of file mapperCreate.c.

{ return Map_NodeVecReadArray(p->vMapBufs);  }

Map_Node_t* Map_ManReadConst1

(

Map_Man_t *

p

)

Definition at line 56 of file mapperCreate.c.

{ return p->pConst1;    }

int Map_ManReadFanoutViolations

(

Map_Man_t *

p

)

Definition at line 70 of file mapperCreate.c.

{ return p->nFanoutViolations;   }  

Mio_Library_t* Map_ManReadGenLib

(

Map_Man_t *

p

)

Definition at line 59 of file mapperCreate.c.

{ return p->pSuperLib->pGenlib; }

Map_Time_t* Map_ManReadInputArrivals

(

Map_Man_t *

p

)

Definition at line 57 of file mapperCreate.c.

{ return p->pInputArrivals; }

int Map_ManReadInputNum

(

Map_Man_t *

p

)

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_Node_t** Map_ManReadInputs

(

Map_Man_t *

p

)

Definition at line 52 of file mapperCreate.c.

{ return p->pInputs;    }

int Map_ManReadOutputNum

(

Map_Man_t *

p

)

Definition at line 50 of file mapperCreate.c.

{ return p->nOutputs;   }

Map_Time_t* Map_ManReadOutputRequireds

(

Map_Man_t *

p

)

Definition at line 58 of file mapperCreate.c.

{ return p->pOutputRequireds; }

Map_Node_t** Map_ManReadOutputs

(

Map_Man_t *

p

)

Definition at line 53 of file mapperCreate.c.

{ return p->pOutputs;   }

float Map_ManReadRequiredGlo

(

Map_Man_t *

p

)

Definition at line 62 of file mapperCreate.c.

{ return p->fRequiredGlo; }

int Map_ManReadVerbose

(

Map_Man_t *

p

)

Definition at line 60 of file mapperCreate.c.

{ return p->fVerbose;   }

void Map_ManSetAreaRecovery	(	Map_Man_t *	p,
		int	fAreaRecovery
	)

Definition at line 64 of file mapperCreate.c.

{ p->fAreaRecovery = fAreaRecovery;}

void Map_ManSetChoiceNodeNum	(	Map_Man_t *	p,
		int	nChoiceNodes
	)

Definition at line 72 of file mapperCreate.c.

{ p->nChoiceNodes = nChoiceNodes; }  

void Map_ManSetChoiceNum	(	Map_Man_t *	p,
		int	nChoices
	)

Definition at line 73 of file mapperCreate.c.

{ p->nChoices = nChoices;     }   

void Map_ManSetDelayTarget	(	Map_Man_t *	p,
		float	DelayTarget
	)

Definition at line 65 of file mapperCreate.c.

{ p->DelayTarget = DelayTarget;}

void Map_ManSetFanoutViolations	(	Map_Man_t *	p,
		int	nVio
	)

Definition at line 71 of file mapperCreate.c.

{ p->nFanoutViolations = nVio;   }  

void Map_ManSetInputArrivals	(	Map_Man_t *	p,
		Map_Time_t *	pArrivals
	)

Definition at line 66 of file mapperCreate.c.

{ p->pInputArrivals = pArrivals;    }

void Map_ManSetNumIterations	(	Map_Man_t *	p,
		int	nIterations
	)

Definition at line 69 of file mapperCreate.c.

{ p->nIterations = nIterations;     }

void Map_ManSetObeyFanoutLimits	(	Map_Man_t *	p,
		int	fObeyFanoutLimits
	)

Definition at line 68 of file mapperCreate.c.

{ p->fObeyFanoutLimits = fObeyFanoutLimits;     }

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

Definition at line 63 of file mapperCreate.c.

{ p->ppOutputNames = ppNames;}

void Map_ManSetOutputRequireds	(	Map_Man_t *	p,
		Map_Time_t *	pRequireds
	)

Definition at line 67 of file mapperCreate.c.

{ p->pOutputRequireds = pRequireds; }

void Map_ManSetSwitching	(	Map_Man_t *	p,
		int	fSwitching
	)

Definition at line 75 of file mapperCreate.c.

{ p->fSwitching = fSwitching; }   

void Map_ManSetVerbose	(	Map_Man_t *	p,
		int	fVerbose
	)

Definition at line 74 of file mapperCreate.c.

{ p->fVerbose = fVerbose;     }   

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

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

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 552 of file mapperCreate.c.

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

int Map_NodeComparePhase	(	Map_Node_t *	p1,
		Map_Node_t *	p2
	)

Definition at line 116 of file mapperCreate.c.

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

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

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

int Map_NodeIsAnd

(

Map_Node_t *

p

)

Definition at line 115 of file mapperCreate.c.

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

int Map_NodeIsBuf

(

Map_Node_t *

p

)

Definition at line 114 of file mapperCreate.c.

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

int Map_NodeIsConst

(

Map_Node_t *

p

)

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

Synopsis [Checks the type of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 112 of file mapperCreate.c.

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

int Map_NodeIsVar

(

Map_Node_t *

p

)

Definition at line 113 of file mapperCreate.c.

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

Map_Cut_t* Map_NodeReadCutBest	(	Map_Node_t *	p,
		int	fPhase
	)

Definition at line 93 of file mapperCreate.c.

{ return p->pCutBest[fPhase];   }

Map_Cut_t* Map_NodeReadCuts

(

Map_Node_t *

p

)

Definition at line 92 of file mapperCreate.c.

{ return p->pCuts;              }

char* Map_NodeReadData	(	Map_Node_t *	p,
		int	fPhase
	)

Definition at line 89 of file mapperCreate.c.

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

int Map_NodeReadLevel

(

Map_Node_t *

p

)

Definition at line 91 of file mapperCreate.c.

{ return Map_Regular(p)->Level; }

Map_Man_t* Map_NodeReadMan

(

Map_Node_t *

p

)

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

Synopsis [Reads parameters from the mapping node.]

Description []

SideEffects []

SeeAlso []

Definition at line 88 of file mapperCreate.c.

{ return p->p;                  }

int Map_NodeReadNum

(

Map_Node_t *

p

)

Definition at line 90 of file mapperCreate.c.

{ return p->Num;                }

Map_Node_t* Map_NodeReadOne

(

Map_Node_t *

p

)

Definition at line 94 of file mapperCreate.c.

{ return p->p1;                 }

Map_Node_t* Map_NodeReadTwo

(

Map_Node_t *

p

)

Definition at line 95 of file mapperCreate.c.

{ return p->p2;                 }

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

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 571 of file mapperCreate.c.

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

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

Definition at line 96 of file mapperCreate.c.

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

void Map_NodeSetNextE	(	Map_Node_t *	p,
		Map_Node_t *	pNextE
	)

Definition at line 97 of file mapperCreate.c.

{ p->pNextE = pNextE;       }

void Map_NodeSetRepr	(	Map_Node_t *	p,
		Map_Node_t *	pRepr
	)

Definition at line 98 of file mapperCreate.c.

{ p->pRepr = pRepr;         }

void Map_NodeSetSwitching	(	Map_Node_t *	p,
		float	Switching
	)

Definition at line 99 of file mapperCreate.c.

{ p->Switching = Switching; }

float Map_SuperLibReadAreaInv

(

Map_SuperLib_t *

p

)

Definition at line 161 of file mapperCreate.c.

{  return p->AreaInv;  }

Map_Time_t Map_SuperLibReadDelayInv

(

Map_SuperLib_t *

p

)

Definition at line 162 of file mapperCreate.c.

{  return p->tDelayInv;}

Mio_Library_t* Map_SuperLibReadGenLib

(

Map_SuperLib_t *

p

)

Definition at line 160 of file mapperCreate.c.

{  return p->pGenlib;  }

int Map_SuperLibReadVarsMax

(

Map_SuperLib_t *

p

)

Definition at line 163 of file mapperCreate.c.

{  return p->nVarsMax; }

int Map_SuperReadFaninNum

(

Map_Super_t *

p

)

Definition at line 154 of file mapperCreate.c.

{  return p->nFanins;  }

Map_Super_t** Map_SuperReadFanins

(

Map_Super_t *

p

)

Definition at line 153 of file mapperCreate.c.

{  return p->pFanins;  }

int Map_SuperReadFanoutLimit

(

Map_Super_t *

p

)

Definition at line 158 of file mapperCreate.c.

{  return p->nFanLimit;}

char* Map_SuperReadFormula

(

Map_Super_t *

p

)

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

Synopsis [Reads parameters from the supergate.]

Description []

SideEffects []

SeeAlso []

Definition at line 150 of file mapperCreate.c.

{  return p->pFormula; }

Map_Super_t* Map_SuperReadNext

(

Map_Super_t *

p

)

Definition at line 155 of file mapperCreate.c.

{  return p->pNext;    }

int Map_SuperReadNum

(

Map_Super_t *

p

)

Definition at line 152 of file mapperCreate.c.

{  return p->Num;      }

int Map_SuperReadNumPhases

(

Map_Super_t *

p

)

Definition at line 156 of file mapperCreate.c.

{  return p->nPhases;  }

unsigned char* Map_SuperReadPhases

(

Map_Super_t *

p

)

Definition at line 157 of file mapperCreate.c.

{  return p->uPhases;  }

Mio_Gate_t* Map_SuperReadRoot

(

Map_Super_t *

p

)

Definition at line 151 of file mapperCreate.c.

{  return p->pRoot;    }

void Map_TableCreate ( Map_Man_t *  pMan )

static

DECLARATIONS ///.

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

FileName [mapperCreate.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:

mapperCreate.c,v 1.15 2005/02/28 05:34:26 alanmi Exp

]

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

Synopsis [Create the unique table of AND gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 424 of file mapperCreate.c.

{
    assert( pMan->pBins == NULL );
    pMan->nBins = Abc_PrimeCudd(5000);
    pMan->pBins = ABC_ALLOC( Map_Node_t *, pMan->nBins );
    memset( pMan->pBins, 0, sizeof(Map_Node_t *) * pMan->nBins );
    pMan->nNodes = 0;
}

void Map_TableResize ( Map_Man_t *  pMan )

static

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

Synopsis [Resizes the table.]

Description []

SideEffects []

SeeAlso []

Definition at line 502 of file mapperCreate.c.

{
    Map_Node_t ** pBinsNew;
    Map_Node_t * pEnt, * pEnt2;
    int nBinsNew, Counter, i;
    abctime clk;
    unsigned Key;

clk = Abc_Clock();
    // get the new table size
    nBinsNew = Abc_PrimeCudd(2 * pMan->nBins); 
    // allocate a new array
    pBinsNew = ABC_ALLOC( Map_Node_t *, nBinsNew );
    memset( pBinsNew, 0, sizeof(Map_Node_t *) * nBinsNew );
    // rehash the entries from the old table
    Counter = 0;
    for ( i = 0; i < pMan->nBins; i++ )
        for ( pEnt = pMan->pBins[i], pEnt2 = pEnt? pEnt->pNext: NULL; pEnt; 
              pEnt = pEnt2, pEnt2 = pEnt? pEnt->pNext: NULL )
        {
            Key = Map_HashKey2( pEnt->p1, pEnt->p2, nBinsNew );
            pEnt->pNext = pBinsNew[Key];
            pBinsNew[Key] = pEnt;
            Counter++;
        }
    assert( Counter == pMan->nNodes - pMan->nInputs );
    if ( pMan->fVerbose )
    {
//        printf( "Increasing the unique table size from %6d to %6d. ", pMan->nBins, nBinsNew );
//        ABC_PRT( "Time", Abc_Clock() - clk );
    }
    // replace the table and the parameters
    ABC_FREE( pMan->pBins );
    pMan->pBins = pBinsNew;
    pMan->nBins = nBinsNew;
}