/**Function*************************************************************
Synopsis [Recursively computes the DFS ordering of the nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_MappingDfsMarked2_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, Map_NodeVec_t * vBoundary, int fFirst )
{
assert( !Map_IsComplement(pNode) );
if ( pNode->fMark1 )
return;
if ( pNode->fMark0 || Map_NodeIsVar(pNode) )
{
pNode->fMark1 = 1;
Map_NodeVecPush(vBoundary, pNode);
return;
}
// visit the transitive fanin
if ( Map_NodeIsAnd(pNode) )
{
Map_MappingDfsMarked2_rec( Map_Regular(pNode->p1), vNodes, vBoundary, 0 );
Map_MappingDfsMarked2_rec( Map_Regular(pNode->p2), vNodes, vBoundary, 0 );
}
// visit the equivalent nodes
if ( !fFirst && pNode->pNextE )
Map_MappingDfsMarked2_rec( pNode->pNextE, vNodes, vBoundary, 0 );
// make sure the node is not visited through the equivalent nodes
assert( pNode->fMark1 == 0 );
// mark the node as visited
pNode->fMark1 = 1;
// add the node to the list
Map_NodeVecPush( vNodes, pNode );
}
/**Function*************************************************************
Synopsis [Add the element while ensuring uniqueness.]
Description [Returns 1 if the element was found, and 0 if it was new. ]
SideEffects []
SeeAlso []
***********************************************************************/
int Map_NodeVecPushUnique( Map_NodeVec_t * p, Map_Node_t * Entry )
{
int i;
for ( i = 0; i < p->nSize; i++ )
if ( p->pArray[i] == Entry )
return 1;
Map_NodeVecPush( p, Entry );
return 0;
}
/**Function*************************************************************
Synopsis [Recursively collect the cuts.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_CutsCollect_rec( Map_Cut_t * pCut, Map_NodeVec_t * vVisited )
{
if ( pCut->fMark )
return;
Map_CutsCollect_rec( Map_CutRegular(pCut->pOne), vVisited );
Map_CutsCollect_rec( Map_CutRegular(pCut->pTwo), vVisited );
assert( pCut->fMark == 0 );
pCut->fMark = 1;
Map_NodeVecPush( vVisited, (Map_Node_t *)pCut );
}
/**Function*************************************************************
Synopsis [Creates a new node.]
Description [This procedure should be called to create the constant
node and the PI nodes first.]
SideEffects []
SeeAlso []
***********************************************************************/
Map_Node_t * Map_NodeCreate( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 )
{
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;
}
/**Function*************************************************************
Synopsis [Recursively computes the DFS ordering of the nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_MappingDfsMarked4_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes )
{
assert( !Map_IsComplement(pNode) );
if ( pNode->fMark1 )
return;
// visit the transitive fanin
if ( Map_NodeIsAnd(pNode) )
{
Map_MappingDfsMarked4_rec( Map_Regular(pNode->p1), vNodes );
Map_MappingDfsMarked4_rec( Map_Regular(pNode->p2), vNodes );
}
// make sure the node is not visited through the equivalent nodes
assert( pNode->fMark1 == 0 );
// mark the node as visited
pNode->fMark1 = 1;
// add the node to the list
Map_NodeVecPush( vNodes, pNode );
}
/**Function*************************************************************
Synopsis [Computes the DFS ordering of the nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_MappingDfs_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, int fCollectEquiv )
{
assert( !Map_IsComplement(pNode) );
if ( pNode->fMark0 )
return;
// visit the transitive fanin
if ( Map_NodeIsAnd(pNode) )
{
Map_MappingDfs_rec( Map_Regular(pNode->p1), vNodes, fCollectEquiv );
Map_MappingDfs_rec( Map_Regular(pNode->p2), vNodes, fCollectEquiv );
}
// visit the equivalent nodes
if ( fCollectEquiv && pNode->pNextE )
Map_MappingDfs_rec( pNode->pNextE, vNodes, fCollectEquiv );
// make sure the node is not visited through the equivalent nodes
assert( pNode->fMark0 == 0 );
// mark the node as visited
pNode->fMark0 = 1;
// add the node to the list
Map_NodeVecPush( vNodes, pNode );
}
/**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;
}
