/**Function*************************************************************
Synopsis [Deallocates the mapping manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_ManFree( Fraig_Man_t * p )
{
int i;
if ( p->fVerbose )
{
if ( p->fChoicing ) Fraig_ManReportChoices( p );
Fraig_ManPrintStats( p );
// Fraig_TablePrintStatsS( p );
// Fraig_TablePrintStatsF( p );
// Fraig_TablePrintStatsF0( p );
}
for ( i = 0; i < p->vNodes->nSize; i++ )
if ( p->vNodes->pArray[i]->vFanins )
{
Fraig_NodeVecFree( p->vNodes->pArray[i]->vFanins );
p->vNodes->pArray[i]->vFanins = NULL;
}
if ( p->vInputs ) Fraig_NodeVecFree( p->vInputs );
if ( p->vNodes ) Fraig_NodeVecFree( p->vNodes );
if ( p->vOutputs ) Fraig_NodeVecFree( p->vOutputs );
if ( p->pTableS ) Fraig_HashTableFree( p->pTableS );
if ( p->pTableF ) Fraig_HashTableFree( p->pTableF );
if ( p->pTableF0 ) Fraig_HashTableFree( p->pTableF0 );
if ( p->pSat ) Msat_SolverFree( p->pSat );
if ( p->vProj ) Msat_IntVecFree( p->vProj );
if ( p->vCones ) Fraig_NodeVecFree( p->vCones );
if ( p->vPatsReal ) Msat_IntVecFree( p->vPatsReal );
if ( p->pModel ) free( p->pModel );
Fraig_MemFixedStop( p->mmNodes, 0 );
Fraig_MemFixedStop( p->mmSims, 0 );
if ( p->pSuppS )
{
FREE( p->pSuppS[0] );
FREE( p->pSuppS );
}
if ( p->pSuppF )
{
FREE( p->pSuppF[0] );
FREE( p->pSuppF );
}
FREE( p->ppOutputNames );
FREE( p->ppInputNames );
FREE( p );
}
/**Function*************************************************************
Synopsis [Prints the node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_PrintNode( Fraig_Man_t * p, Fraig_Node_t * pNode )
{
Fraig_NodeVec_t * vNodes;
Fraig_Node_t * pTemp;
int fCompl1, fCompl2, i;
vNodes = Fraig_DfsOne( p, pNode, 0 );
for ( i = 0; i < vNodes->nSize; i++ )
{
pTemp = vNodes->pArray[i];
if ( Fraig_NodeIsVar(pTemp) )
{
printf( "%3d : PI ", pTemp->Num );
Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimR, 20 );
printf( " " );
Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimD, 20 );
printf( " %d\n", pTemp->fInv );
continue;
}
fCompl1 = Fraig_IsComplement(pTemp->p1);
fCompl2 = Fraig_IsComplement(pTemp->p2);
printf( "%3d : %c%3d %c%3d ", pTemp->Num,
(fCompl1? '-':'+'), Fraig_Regular(pTemp->p1)->Num,
(fCompl2? '-':'+'), Fraig_Regular(pTemp->p2)->Num );
Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimR, 20 );
printf( " " );
Fraig_PrintBinary( stdout, (unsigned *)&pTemp->puSimD, 20 );
printf( " %d\n", pTemp->fInv );
}
Fraig_NodeVecFree( vNodes );
}
/**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 []
***********************************************************************/
int Fraig_ManCheckConsistency( Fraig_Man_t * p )
{
Fraig_Node_t * pNode;
Fraig_NodeVec_t * pVec;
int i;
pVec = Fraig_Dfs( p, 0 );
for ( i = 0; i < pVec->nSize; i++ )
{
pNode = pVec->pArray[i];
if ( Fraig_NodeIsVar(pNode) )
{
if ( pNode->pRepr )
printf( "Primary input %d is a secondary node.\n", pNode->Num );
}
else if ( Fraig_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 ( Fraig_Regular(pNode->p1)->pRepr )
printf( "Internal node %d has first fanin %d that is a secondary node.\n",
pNode->Num, Fraig_Regular(pNode->p1)->Num );
if ( Fraig_Regular(pNode->p2)->pRepr )
printf( "Internal node %d has second fanin %d that is a secondary node.\n",
pNode->Num, Fraig_Regular(pNode->p2)->Num );
}
}
Fraig_NodeVecFree( pVec );
return 1;
}
/**Function*************************************************************
Synopsis [Sets the number of fanouts (none, one, or many).]
Description [This procedure collects the nodes reachable from
the POs of the AIG and sets the type of fanout counter (none, one,
or many) for each node. This procedure is useful to determine
fanout-free cones of AND-nodes, which is helpful for rebalancing
the AIG (see procedure Fraig_ManRebalance, or something like that).]
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_ManMarkRealFanouts( Fraig_Man_t * p )
{
Fraig_NodeVec_t * vNodes;
Fraig_Node_t * pNodeR;
int i;
// collect the nodes reachable
vNodes = Fraig_Dfs( p, 0 );
// clean the fanouts field
for ( i = 0; i < vNodes->nSize; i++ )
{
vNodes->pArray[i]->nFanouts = 0;
vNodes->pArray[i]->pData0 = NULL;
}
// mark reachable nodes by setting the two-bit counter pNode->nFans
for ( i = 0; i < vNodes->nSize; i++ )
{
pNodeR = Fraig_Regular(vNodes->pArray[i]->p1);
if ( pNodeR && ++pNodeR->nFanouts == 3 )
pNodeR->nFanouts = 2;
pNodeR = Fraig_Regular(vNodes->pArray[i]->p2);
if ( pNodeR && ++pNodeR->nFanouts == 3 )
pNodeR->nFanouts = 2;
}
Fraig_NodeVecFree( vNodes );
}
/**Function*************************************************************
Synopsis [Returns 1 if pOld is in the TFI of pNew.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Fraig_CheckTfi2( Fraig_Man_t * pMan, Fraig_Node_t * pOld, Fraig_Node_t * pNew )
{
Fraig_NodeVec_t * vNodes;
int RetValue;
vNodes = Fraig_DfsOne( pMan, pNew, 1 );
RetValue = (pOld->TravId == pMan->nTravIds);
Fraig_NodeVecFree( vNodes );
return RetValue;
}
/**Function*************************************************************
Synopsis [Computes the DFS ordering of the nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Fraig_CountNodes( Fraig_Man_t * pMan, int fEquiv )
{
Fraig_NodeVec_t * vNodes;
int RetValue;
vNodes = Fraig_Dfs( pMan, fEquiv );
RetValue = vNodes->nSize;
Fraig_NodeVecFree( vNodes );
return RetValue;
}
/**Function*************************************************************
Synopsis [Returns the array of nodes to be combined into one multi-input AND-gate.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Fraig_DetectFanoutFreeConeMux( Fraig_Man_t * pMan, Fraig_Node_t * pNode )
{
Fraig_NodeVec_t * vFanins;
Fraig_NodeVec_t * vInside;
int nCubes;
extern int Fraig_CutSopCountCubes( Fraig_Man_t * pMan, Fraig_NodeVec_t * vFanins, Fraig_NodeVec_t * vInside );
vFanins = Fraig_NodeVecAlloc( 8 );
vInside = Fraig_NodeVecAlloc( 8 );
Fraig_DetectFanoutFreeConeMux_rec( pNode, vFanins, vInside, 1 );
assert( vInside->pArray[vInside->nSize-1] == pNode );
// nCubes = Fraig_CutSopCountCubes( pMan, vFanins, vInside );
nCubes = 0;
printf( "%d(%d)", vFanins->nSize, nCubes );
Fraig_NodeVecFree( vFanins );
Fraig_NodeVecFree( vInside );
}
