cutOracle.c File Reference

#include "cutInt.h"

Include dependency graph for cutOracle.c:

Go to the source code of this file.

Classes
struct	Cut_OracleStruct_t_
	DECLARATIONS ///. More...

Functions
Cut_Oracle_t *	Cut_OracleStart (Cut_Man_t *pMan)
	FUNCTION DEFINITIONS ///.
void	Cut_OracleStop (Cut_Oracle_t *p)
void	Cut_OracleSetFanoutCounts (Cut_Oracle_t *p, Vec_Int_t *vFanCounts)
int	Cut_OracleReadDrop (Cut_Oracle_t *p)
void	Cut_OracleNodeSetTriv (Cut_Oracle_t *p, int Node)
Cut_Cut_t *	Cut_OracleComputeCuts (Cut_Oracle_t *p, int Node, int Node0, int Node1, int fCompl0, int fCompl1)
void	Cut_OracleFreeCuts (Cut_Oracle_t *p, int Node)
void	Cut_OracleTryDroppingCuts (Cut_Oracle_t *p, int Node)

Function Documentation

Cut_OracleComputeCuts()

Cut_Cut_t * Cut_OracleComputeCuts	(	Cut_Oracle_t *	p,
		int	Node,
		int	Node0,
		int	Node1,
		int	fCompl0,
		int	fCompl1 )

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

Synopsis [Reconstruct the cuts of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 320 of file cutOracle.c.

{
    Cut_Cut_t * pList = NULL, ** ppTail = &pList;
    Cut_Cut_t * pCut, * pCut0, * pCut1, * pList0, * pList1;
    int iCutStart, nCuts, i, Entry;
    abctime clk = Abc_Clock();
 
    // get the cuts of the children
    pList0 = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node0 );
    pList1 = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node1 );
    assert( pList0 && pList1 );
 
    // get the complemented attribute of the cut
    p->fSimul = (fCompl0 ^ pList0->fSimul) & (fCompl1 ^ pList1->fSimul);
 
    // collect the cuts
    Vec_PtrClear( p->vCuts0 );
    Cut_ListForEachCut( pList0, pCut )
        Vec_PtrPush( p->vCuts0, pCut );
    Vec_PtrClear( p->vCuts1 );
    Cut_ListForEachCut( pList1, pCut )
        Vec_PtrPush( p->vCuts1, pCut );
 
    // get the first and last cuts of this node
    nCuts = Vec_IntEntry(p->vNodeCuts, Node);
    iCutStart = Vec_IntEntry(p->vNodeStarts, Node);
 
    // create trivial cut
    assert( Vec_IntEntry(p->vCutPairs, iCutStart) == 0 );
    pCut = Cut_CutTriv( p, Node );
    *ppTail = pCut;
    ppTail = &pCut->pNext;
    // create other cuts
    for ( i = 1; i < nCuts; i++ )
    {
        Entry = Vec_IntEntry( p->vCutPairs, iCutStart + i );
        pCut0 = (Cut_Cut_t *)Vec_PtrEntry( p->vCuts0, Entry & 0xFFFF );
        pCut1 = (Cut_Cut_t *)Vec_PtrEntry( p->vCuts1, Entry >> 16 );
        pCut  = Cut_CutMerge( p, pCut0, pCut1 );
        *ppTail = pCut;
        ppTail = &pCut->pNext;
        // compute the truth table
        if ( p->pParams->fTruth )
            Cut_TruthComputeOld( pCut, pCut0, pCut1, fCompl0, fCompl1 );
    }
    *ppTail = NULL;
 
    // write the new cut
    assert( Vec_PtrEntry( p->vCutsNew, Node ) == NULL );
    Vec_PtrWriteEntry( p->vCutsNew, Node, pList );
p->timeTotal += Abc_Clock() - clk;
    return pList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_OracleFreeCuts()

void Cut_OracleFreeCuts	(	Cut_Oracle_t *	p,
		int	Node )

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

Synopsis [Deallocates the cuts at the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 385 of file cutOracle.c.

{
    Cut_Cut_t * pList, * pCut, * pCut2;
    pList = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node );
    if ( pList == NULL )
        return;
    Cut_ListForEachCutSafe( pList, pCut, pCut2 )
        Extra_MmFixedEntryRecycle( p->pMmCuts, (char *)pCut );
    Vec_PtrWriteEntry( p->vCutsNew, Node, pList );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_OracleNodeSetTriv()

void Cut_OracleNodeSetTriv	(	Cut_Oracle_t *	p,
		int	Node )

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

Synopsis [Sets the trivial cut for the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file cutOracle.c.

{
    assert( Vec_PtrEntry( p->vCutsNew, Node ) == NULL );
    Vec_PtrWriteEntry( p->vCutsNew, Node, Cut_CutTriv(p, Node) );
}

Here is the caller graph for this function:

Cut_OracleReadDrop()

int Cut_OracleReadDrop

(

Cut_Oracle_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 176 of file cutOracle.c.

{
    return p->pParams->fDrop;
}

Here is the caller graph for this function:

Cut_OracleSetFanoutCounts()

void Cut_OracleSetFanoutCounts	(	Cut_Oracle_t *	p,
		Vec_Int_t *	vFanCounts )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 160 of file cutOracle.c.

{
    p->vFanCounts = vFanCounts;
}

Here is the caller graph for this function:

Cut_OracleStart()

Cut_Oracle_t * Cut_OracleStart

(

Cut_Man_t *

pMan

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Starts the cut oracle.]

Description []

SideEffects []

SeeAlso []

Definition at line 73 of file cutOracle.c.

{
    Cut_Oracle_t * p;
 
    assert( pMan->pParams->nVarsMax >= 3 && pMan->pParams->nVarsMax <= CUT_SIZE_MAX );
    assert( pMan->pParams->fRecord );
 
    p = ABC_ALLOC( Cut_Oracle_t, 1 );
    memset( p, 0, sizeof(Cut_Oracle_t) );
 
    // set and correct parameters
    p->pParams     = pMan->pParams;
 
    // transfer the recording info
    p->vNodeCuts   = pMan->vNodeCuts;    pMan->vNodeCuts   = NULL;
    p->vNodeStarts = pMan->vNodeStarts;  pMan->vNodeStarts = NULL;
    p->vCutPairs   = pMan->vCutPairs;    pMan->vCutPairs   = NULL;
 
    // prepare storage for cuts
    p->vCutsNew = Vec_PtrAlloc( p->pParams->nIdsMax );
    Vec_PtrFill( p->vCutsNew, p->pParams->nIdsMax, NULL );
    p->vCuts0 = Vec_PtrAlloc( 100 );
    p->vCuts1 = Vec_PtrAlloc( 100 );
 
    // entry size
    p->EntrySize = sizeof(Cut_Cut_t) + p->pParams->nVarsMax * sizeof(int);
    if ( p->pParams->fTruth )
    {
        if ( p->pParams->nVarsMax > 8 )
        {
            p->pParams->fTruth = 0;
            printf( "Skipping computation of truth table for more than 8 inputs.\n" );
        }
        else
        {
            p->nTruthWords = Cut_TruthWords( p->pParams->nVarsMax );
            p->EntrySize += p->nTruthWords * sizeof(unsigned);
        }
    }
    // memory for cuts
    p->pMmCuts = Extra_MmFixedStart( p->EntrySize );
    return p;
}

Here is the call graph for this function:

Cut_OracleStop()

void Cut_OracleStop

(

Cut_Oracle_t *

p

)

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

Synopsis [Stop the cut oracle.]

Description []

SideEffects []

SeeAlso []

Definition at line 127 of file cutOracle.c.

{
//    if ( p->pParams->fVerbose )
    {
        printf( "Cut computation statistics with oracle:\n" );
        printf( "Current cuts      = %8d. (Trivial = %d.)\n", p->nCuts-p->nCutsTriv, p->nCutsTriv );
        ABC_PRT( "Total time ", p->timeTotal );
    }
 
    if ( p->vCuts0 )      Vec_PtrFree( p->vCuts0 );
    if ( p->vCuts1 )      Vec_PtrFree( p->vCuts1 );
    if ( p->vCutsNew )    Vec_PtrFree( p->vCutsNew );
    if ( p->vFanCounts )  Vec_IntFree( p->vFanCounts );
 
    if ( p->vNodeCuts )   Vec_IntFree( p->vNodeCuts );
    if ( p->vNodeStarts ) Vec_IntFree( p->vNodeStarts );
    if ( p->vCutPairs )   Vec_IntFree( p->vCutPairs );
 
    Extra_MmFixedStop( p->pMmCuts );
    ABC_FREE( p ); 
}

Here is the call graph for this function:

Cut_OracleTryDroppingCuts()

void Cut_OracleTryDroppingCuts	(	Cut_Oracle_t *	p,
		int	Node )

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

Synopsis [Consider dropping cuts if they are useless by now.]

Description []

SideEffects []

SeeAlso []

Definition at line 407 of file cutOracle.c.

{
    int nFanouts;
    assert( p->vFanCounts );
    nFanouts = Vec_IntEntry( p->vFanCounts, Node );
    assert( nFanouts > 0 );
    if ( --nFanouts == 0 )
        Cut_OracleFreeCuts( p, Node );
    Vec_IntWriteEntry( p->vFanCounts, Node, nFanouts );
}

Here is the call graph for this function:

Here is the caller graph for this function: