abcFxu.c File Reference

#include "base/abc/abc.h"
#include "opt/fxu/fxu.h"

Include dependency graph for abcFxu.c:

Go to the source code of this file.

Functions
int	Fxu_FastExtract (Fxu_Data_t *pData)
	FUNCTION DEFINITIONS ///.
void	Abc_NtkSetDefaultFxParams (Fxu_Data_t *p)
	FUNCTION DEFINITIONS ///.
int	Abc_NtkFastExtract (Abc_Ntk_t *pNtk, Fxu_Data_t *p)
void	Abc_NtkFxuFreeInfo (Fxu_Data_t *p)

Function Documentation

Abc_NtkFastExtract()

int Abc_NtkFastExtract	(	Abc_Ntk_t *	pNtk,
		Fxu_Data_t *	p )

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

Synopsis [Performs fast_extract on the current network.]

Description [Takes the network and the maximum number of nodes to extract. Uses the concurrent double-cube and single cube divisor extraction procedure. Modifies the network in the end, after extracting all nodes. Note that Ntk_NetworkSweep() may increase the performance of this procedure because the single-literal nodes will not be created in the sparse matrix. Returns 1 if the network has been changed.]

SideEffects []

SeeAlso []

Definition at line 83 of file abcFxu.c.

{
    assert( Abc_NtkIsLogic(pNtk) );
    // if the network is already in the SOP form, it may come from BLIF file
    // and it may not be SCC-free, in which case FXU will not work correctly
    if ( Abc_NtkIsSopLogic(pNtk) )
    { // to make sure the SOPs are SCC-free
//        Abc_NtkSopToBdd(pNtk);
//        Abc_NtkBddToSop(pNtk, 1);
    }
    // get the network in the SOP form
    if ( !Abc_NtkToSop(pNtk, -1, ABC_INFINITY) )
    {
        printf( "Abc_NtkFastExtract(): Converting to SOPs has failed.\n" );
        return 0;
    }
    // check if the network meets the requirements
    if ( !Abc_NtkFxuCheck(pNtk) )
    {
        printf( "Abc_NtkFastExtract: Nodes have duplicated or complemented fanins. FXU is not performed.\n" );
        return 0;
    }
    // sweep removes useless nodes
    Abc_NtkCleanup( pNtk, 0 );
    // collect information about the covers
    Abc_NtkFxuCollectInfo( pNtk, p );
    // call the fast extract procedure
    if ( Fxu_FastExtract(p) > 0 )
    {
        // update the network
        Abc_NtkFxuReconstruct( pNtk, p );
        // make sure everything is okay
        if ( !Abc_NtkCheck( pNtk ) )
            printf( "Abc_NtkFastExtract: The network check has failed.\n" );
        return 1;
    }
    else
        printf( "Warning: The network has not been changed by \"fx\".\n" );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkFxuFreeInfo()

void Abc_NtkFxuFreeInfo

(

Fxu_Data_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 207 of file abcFxu.c.

{
    int i;
    // free the arrays of new fanins
    if ( p->vFaninsNew )
        for ( i = 0; i < p->vFaninsNew->nSize; i++ )
            if ( p->vFaninsNew->pArray[i] )
                Vec_IntFree( (Vec_Int_t *)p->vFaninsNew->pArray[i] );
    // free the arrays
    if ( p->vSops      ) Vec_PtrFree( p->vSops      );
    if ( p->vSopsNew   ) Vec_PtrFree( p->vSopsNew   );
    if ( p->vFanins    ) Vec_PtrFree( p->vFanins    );
    if ( p->vFaninsNew ) Vec_PtrFree( p->vFaninsNew );
//    ABC_FREE( p );
}

Here is the caller graph for this function:

Abc_NtkSetDefaultFxParams()

void Abc_NtkSetDefaultFxParams

(

Fxu_Data_t *

p

)

FUNCTION DEFINITIONS ///.

MACRO DEFINITIONS ///.

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

Synopsis [Sets default values of the FXU parameters.]

Description []

SideEffects []

SeeAlso []

Definition at line 52 of file abcFxu.c.

{
    memset( p, 0, sizeof(Fxu_Data_t) );
    p->nSingleMax =  20000;
    p->nPairsMax  =  30000;
    p->nNodesExt  =1000000;
    p->WeightMin  =      0;
    p->LitCountMax=      4;
    p->fOnlyS     =      0;
    p->fOnlyD     =      0;
    p->fUse0      =      0;
    p->fUseCompl  =      1;
    p->fVerbose   =      0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Fxu_FastExtract()

int Fxu_FastExtract ( Fxu_Data_t * pData )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Performs fast_extract on a set of covers.]

Description [All the covers are given in the array p->vSops. The resulting covers are returned in the array p->vSopsNew. The entries in these arrays correspond to objects in the network. The entries corresponding to the PI and objects with trivial covers are NULL. The number of extracted covers (not exceeding p->nNodesExt) is returned. Two other things are important for the correct operation of this procedure: (1) The input covers do not have duplicated fanins and are SCC-free. (2) The fanins array contains the numbers of the fanin objects.]

SideEffects []

SeeAlso []

Definition at line 58 of file fxu.c.

{
    int fScrollLines = 0;
    Fxu_Matrix * p;
    Fxu_Single * pSingle;
    Fxu_Double * pDouble;
    int Weight1, Weight2, Weight3;
    int Counter = 0;
 
    s_MemoryTotal = 0;
    s_MemoryPeak  = 0;
 
    // create the matrix
    p = Fxu_CreateMatrix( pData );
    if ( p == NULL )
        return -1;
//    if ( pData->fVerbose )
//        printf( "Memory usage after construction: Total = %d. Peak = %d.\n", s_MemoryTotal, s_MemoryPeak );
//Fxu_MatrixPrint( NULL, p );
 
    if ( pData->fOnlyS )
    {
        pData->nNodesNew = 0;
        do
        {
            Weight1 = Fxu_HeapSingleReadMaxWeight( p->pHeapSingle );
            if ( pData->fVerbose )
                printf( "Div %5d : Best single = %5d.%s", Counter++, Weight1, fScrollLines?"\n":"\r" );
            if ( Weight1 > pData->WeightMin || (Weight1 == 0 && pData->fUse0) )
                Fxu_UpdateSingle( p );
            else
                break;
        }
        while ( ++pData->nNodesNew < pData->nNodesExt );
    }
    else if ( pData->fOnlyD )
    {
        pData->nNodesNew = 0;
        do
        {
            Weight2 = Fxu_HeapDoubleReadMaxWeight( p->pHeapDouble );
            if ( pData->fVerbose )
                printf( "Div %5d : Best double = %5d.%s", Counter++, Weight2, fScrollLines?"\n":"\r" );
            if ( Weight2 > pData->WeightMin || (Weight2 == 0 && pData->fUse0) )
                Fxu_UpdateDouble( p );
            else
                break;
        }
        while ( ++pData->nNodesNew < pData->nNodesExt );
    }
    else if ( !pData->fUseCompl )
    {
        pData->nNodesNew = 0;
        do
        {
            Weight1 = Fxu_HeapSingleReadMaxWeight( p->pHeapSingle );
            Weight2 = Fxu_HeapDoubleReadMaxWeight( p->pHeapDouble );
 
            if ( pData->fVerbose )
                printf( "Div %5d : Best double = %5d. Best single = %5d.%s", Counter++, Weight2, Weight1, fScrollLines?"\n":"\r" );
//Fxu_Select( p, &pSingle, &pDouble );
 
            if ( Weight1 >= Weight2 )
            {
                if ( Weight1 > pData->WeightMin || (Weight1 == 0 && pData->fUse0) )
                    Fxu_UpdateSingle( p );
                else
                    break;
            }
            else
            {
                if ( Weight2 > pData->WeightMin || (Weight2 == 0 && pData->fUse0) )
                    Fxu_UpdateDouble( p );
                else
                    break;
            }
        }
        while ( ++pData->nNodesNew < pData->nNodesExt );
    }
    else
    { // use the complement
        pData->nNodesNew = 0;
        do
        {
            Weight1 = Fxu_HeapSingleReadMaxWeight( p->pHeapSingle );
            Weight2 = Fxu_HeapDoubleReadMaxWeight( p->pHeapDouble );
 
            // select the best single and double
            Weight3 = Fxu_Select( p, &pSingle, &pDouble );
            if ( pData->fVerbose )
                printf( "Div %5d : Best double = %5d. Best single = %5d. Best complement = %5d.%s", 
                    Counter++, Weight2, Weight1, Weight3, fScrollLines?"\n":"\r" );
 
            if ( Weight3 > pData->WeightMin || (Weight3 == 0 && pData->fUse0) )
                Fxu_Update( p, pSingle, pDouble );
            else
                break;
        }
        while ( ++pData->nNodesNew < pData->nNodesExt );
    }
 
    if ( pData->fVerbose )
        printf( "Total single = %3d. Total double = %3d. Total compl = %3d.                    \n", 
        p->nDivs1, p->nDivs2, p->nDivs3 );
 
    // create the new covers
    if ( pData->nNodesNew )
        Fxu_CreateCovers( p, pData );
    Fxu_MatrixDelete( p );
//    printf( "Memory usage after deallocation:   Total = %d. Peak = %d.\n", s_MemoryTotal, s_MemoryPeak );
    if ( pData->nNodesNew == pData->nNodesExt )
        printf( "Warning: The limit on the number of extracted divisors has been reached.\n" );
    return pData->nNodesNew;
}

Here is the call graph for this function:

Here is the caller graph for this function: