/**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 []
***********************************************************************/
Map_Man_t * Map_ManCreate( int nInputs, int nOutputs, int fVerbose )
{
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->vNodesAll = Map_NodeVecAlloc( 100 );
p->vNodesTemp = Map_NodeVecAlloc( 100 );
p->vMapping = 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;
}
/**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 []
***********************************************************************/
Map_Node_t * Map_TableLookup( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2 )
{
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;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Map_Node_t * Map_NodeBuf( Map_Man_t * p, Map_Node_t * p1 )
{
Map_Node_t * pNode = Map_NodeCreate( p, p1, NULL );
Map_NodeVecPush( p->vMapBufs, pNode );
return pNode;
}
