#include "pla.h"
#include "misc/vec/vecHash.h"
#include "misc/vec/vecQue.h"

Include dependency graph for plaFxch.c:

Classes
struct	Fxch_Obj_t_

struct	Fxch_Man_t_

Macros
#define	Fxch_ManForEachCubeVec(vVec, vCubes, vCube, i)

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Fxch_Obj_t_	Fxch_Obj_t
	DECLARATIONS ///.

typedef struct Fxch_Man_t_	Fxch_Man_t
	TYPEDEF DECLARATIONS ///.

Functions
void	Fxch_ManWriteBlif (char pFileName, Vec_Wec_t vCubes, Vec_Wrd_t *vDivs)
	FUNCTION DEFINITIONS ///.

Fxch_Man_t *	Fxch_ManStart (Vec_Wec_t vCubes, Vec_Wec_t vLits)

void	Fxch_ManStop (Fxch_Man_t *p)

int	Fxch_DivisorAdd (Fxch_Man_t *p, int Lit0, int Lit1, int Weight)

void	Fxch_DivisorRemove (Fxch_Man_t *p, int Lit0, int Lit1, int Weight)

int	Fxch_TabSingleDivisors (Fxch_Man_t *p, int iCube, int fAdd)

int	Fxch_TabDoubleDivisors (Fxch_Man_t *p, int iCube, int fAdd)

void	Fxch_ManCreateDivisors (Fxch_Man_t *p)

void	Fxch_ManUpdate (Fxch_Man_t *p, int iDiv)

int	Fxch_ManFastExtract (Fxch_Man_t *p, int fVerbose, int fVeryVerbose)

int	Pla_ManPerformFxch (Pla_Man_t *p)

Macro Definition Documentation

◆ Fxch_ManForEachCubeVec

#define Fxch_ManForEachCubeVec	(	vVec,
		vCubes,
		vCube,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(vVec)) && ((vCube) = Vec_WecEntry(vCubes, Vec_IntEntry(vVec, i))); i++ )

Definition at line 72 of file plaFxch.c.

72#define Fxch_ManForEachCubeVec( vVec, vCubes, vCube, i ) \

73 for ( i = 0; (i < Vec_IntSize(vVec)) && ((vCube) = Vec_WecEntry(vCubes, Vec_IntEntry(vVec, i))); i++ )

Typedef Documentation

◆ Fxch_Man_t

typedef struct Fxch_Man_t_ Fxch_Man_t

TYPEDEF DECLARATIONS ///.

Definition at line 42 of file plaFxch.c.

◆ Fxch_Obj_t

typedef typedefABC_NAMESPACE_IMPL_START struct Fxch_Obj_t_ Fxch_Obj_t

DECLARATIONS ///.

CFile****************************************************************

FileName [plaFxch.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [SOP manager.]

Synopsis [Scalable SOP transformations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - March 18, 2015.]

Revision [

Id: plaFxch.c,v 1.00 2014/09/12 00:00:00 alanmi Exp

]

Definition at line 31 of file plaFxch.c.

Function Documentation

◆ Fxch_DivisorAdd()

int Fxch_DivisorAdd	(	Fxch_Man_t *	p,
		int	Lit0,
		int	Lit1,
		int	Weight )

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

Synopsis [Divisor addition removal.]

Description []

SideEffects []

SeeAlso []

Definition at line 344 of file plaFxch.c.

{
    int iDiv;
    assert( Lit0 != Lit1 );
    if ( Lit0 < Lit1 )
        iDiv = Hash_Int2ManInsert( p->vHash, Lit0, Lit1, 0 );
    else
        iDiv = Hash_Int2ManInsert( p->vHash, Lit1, Lit0, 0 );
    if ( iDiv == Vec_FltSize(&p->vWeights) )
    {
        Vec_FltPush( &p->vWeights, -2 );
        Vec_WecPushLevel( &p->vPairs );
        assert( Vec_FltSize(&p->vWeights) == Vec_WecSize(&p->vPairs) );
    }
    Vec_FltAddToEntry( &p->vWeights, iDiv, Weight );
    if ( p->vPrio )
    {
        if ( Vec_QueIsMember(p->vPrio, iDiv) )
            Vec_QueUpdate( p->vPrio, iDiv );
        else 
            Vec_QuePush( p->vPrio, iDiv );
        //assert( iDiv < Vec_QueSize(p->vPrio) );
    }
    return iDiv;
}

Here is the caller graph for this function:

◆ Fxch_DivisorRemove()

void Fxch_DivisorRemove	(	Fxch_Man_t *	p,
		int	Lit0,
		int	Lit1,
		int	Weight )

Definition at line 369 of file plaFxch.c.

{
    int iDiv;
    assert( Lit0 != Lit1 );
    if ( Lit0 < Lit1 )
        iDiv = *Hash_Int2ManLookup( p->vHash, Lit0, Lit1 );
    else
        iDiv = *Hash_Int2ManLookup( p->vHash, Lit1, Lit0 );
    assert( iDiv > 0 && iDiv < Vec_FltSize(&p->vWeights) );
    Vec_FltAddToEntry( &p->vWeights, iDiv, -Weight );
    if ( Vec_QueIsMember(p->vPrio, iDiv) )
        Vec_QueUpdate( p->vPrio, iDiv );
}

Here is the caller graph for this function:

◆ Fxch_ManCreateDivisors()

void Fxch_ManCreateDivisors ( Fxch_Man_t * p )

Definition at line 585 of file plaFxch.c.

{
    float Weight;  int i;
    // alloc hash table
    assert( p->vHash == NULL );
    p->vHash = Hash_IntManStart( 1000 );
    // create single-cube two-literal divisors
    for ( i = 0; i < Vec_WecSize(&p->vCubes); i++ )
        Fxch_TabSingleDivisors( p, i, 1 ); // add - no update
    // create two-cube divisors
    for ( i = 0; i < Vec_WecSize(&p->vCubes); i++ )
        Fxch_TabDoubleDivisors( p, i, 1 ); // add - no update
    // create queue with all divisors
    p->vPrio = Vec_QueAlloc( Vec_FltSize(&p->vWeights) );
    Vec_QueSetPriority( p->vPrio, Vec_FltArrayP(&p->vWeights) );
    Vec_FltForEachEntry( &p->vWeights, Weight, i )
        if ( Weight > 0.0 )
            Vec_QuePush( p->vPrio, i );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Fxch_ManFastExtract()

int Fxch_ManFastExtract	(	Fxch_Man_t *	p,
		int	fVerbose,
		int	fVeryVerbose )

Definition at line 798 of file plaFxch.c.

{
    int nNewNodesMax = ABC_INFINITY;
    abctime clk = Abc_Clock();
    int i, iDiv;
    Fxch_ManCreateDivisors( p );
//    Fxch_PrintDivisors( p );
    if ( fVerbose )
        Fxch_PrintStats( p, Abc_Clock() - clk );
    p->timeStart = Abc_Clock();
    for ( i = 0; i < nNewNodesMax && Vec_QueTopPriority(p->vPrio) > 0.0; i++ )
    {
        iDiv = Vec_QuePop(p->vPrio);
        //if ( fVerbose )
        //    Fxch_PrintStats( p, Abc_Clock() - clk );
        if ( fVeryVerbose )
            Fxch_PrintDivOne( p, iDiv );
        Fxch_ManUpdate( p, iDiv );
    }
    if ( fVerbose )
        Fxch_PrintStats( p, Abc_Clock() - clk );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Fxch_ManStart()

Fxch_Man_t * Fxch_ManStart	(	Vec_Wec_t *	vCubes,
		Vec_Wec_t *	vLits )

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

Synopsis [Starting the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 164 of file plaFxch.c.

{
    Vec_Int_t * vCube;  int i, LogSize;
    Fxch_Man_t * p = ABC_CALLOC( Fxch_Man_t, 1 );
    p->vCubes = *vCubes;
    p->vLits  = *vLits;
    p->nVars  = Vec_WecSize(vLits)/2;
    p->nLits  = 0;
    // random numbers
    Gia_ManRandom( 1 );
    Vec_IntGrow( &p->vRands, 2*p->nVars );
    for ( i = 0; i < 2*p->nVars; i++ )
        Vec_IntPush( &p->vRands, Gia_ManRandom(0) & 0x3FFFFFF ); // assert( LogSize <= 26 );
    // create cube links
    Vec_IntGrow( &p->vCubeLinks, Vec_WecSize(&p->vCubes) );
    Vec_WecForEachLevel( vCubes, vCube, i )
    {
        Vec_IntPush( &p->vCubeLinks, p->nLits+1 );
        p->nLits += Vec_IntSize(vCube);
    }
    assert( Vec_IntSize(&p->vCubeLinks) == Vec_WecSize(&p->vCubes) );
    // create table
    LogSize = Abc_Base2Log( p->nLits+1 );
    assert( LogSize <= 26 );
    p->SizeMask = (1 << LogSize) - 1;
    p->pBins = ABC_CALLOC( Fxch_Obj_t, p->SizeMask + 1 );
    assert( p->nLits+1 < p->SizeMask+1 );
    // divisor weights and cube pairs
    Vec_FltGrow( &p->vWeights, 1000 );
    Vec_FltPush( &p->vWeights, -1 );
    Vec_WecGrow( &p->vPairs, 1000 );
    Vec_WecPushLevel( &p->vPairs );
    // prepare divisors
    Vec_WrdGrow( &p->vDivs, p->nVars + 1000 );
    Vec_WrdFill( &p->vDivs, p->nVars, 0 );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Fxch_ManStop()

void Fxch_ManStop ( Fxch_Man_t * p )

Definition at line 201 of file plaFxch.c.

{
    Vec_WecErase( &p->vCubes );
    Vec_WecErase( &p->vLits );
    Vec_IntErase( &p->vRands );
    Vec_IntErase( &p->vCubeLinks );
    Hash_IntManStop( p->vHash );
    Vec_QueFree( p->vPrio );
    Vec_FltErase( &p->vWeights );
    Vec_WecErase( &p->vPairs );
    Vec_WrdErase( &p->vDivs );
    Vec_IntErase( &p->vCubesS );
    Vec_IntErase( &p->vCubesD );
    Vec_IntErase( &p->vCube1 );
    Vec_IntErase( &p->vCube2 );
    ABC_FREE( p->pBins );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Fxch_ManUpdate()

void Fxch_ManUpdate	(	Fxch_Man_t *	p,
		int	iDiv )

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

Synopsis [Updates the data-structure when one divisor is selected.]

Description []

SideEffects []

SeeAlso []

Definition at line 617 of file plaFxch.c.

{
    Vec_Int_t * vCube1, * vCube2, * vLitP, * vLitN;
    //int nLitsNew = p->nLits - (int)Vec_FltEntry(&p->vWeights, iDiv);
    int i, Lit0, Lit1, hCube1, hCube2, iVarNew;
    //float Diff = Vec_FltEntry(&p->vWeights, iDiv) - (float)((int)Vec_FltEntry(&p->vWeights, iDiv));
    //assert( Diff > 0.0 && Diff < 1.0 );
 
    // get the divisor and select pivot variables
    Vec_IntPush( &p->vRands, Gia_ManRandom(0) & 0x3FFFFFF ); 
    Vec_IntPush( &p->vRands, Gia_ManRandom(0) & 0x3FFFFFF );
    Lit0 = Hash_IntObjData0( p->vHash, iDiv );
    Lit1 = Hash_IntObjData1( p->vHash, iDiv );
    assert( Lit0 >= 0 && Lit1 >= 0 && Lit0 < Lit1 );
    Vec_WrdPush( &p->vDivs, ((word)Lit1 << 32) | (word)Lit0 );
 
    // if the input cover is not prime, it may happen that we are extracting divisor (x + !x)
    // although it is not strictly correct, it seems to be fine to just skip such divisors
//    if ( Abc_Lit2Var(Lit0) == Abc_Lit2Var(Lit1) && Vec_IntSize(Hsh_VecReadEntry(p->vHash, iDiv)) == 2 )
//        return;
 
    // collect single-cube-divisor cubes
    vLitP = Vec_WecEntry(&p->vLits, Lit0);
    vLitN = Vec_WecEntry(&p->vLits, Lit1);
    Fxch_CompressCubes( p, vLitP );
    Fxch_CompressCubes( p, vLitN );
//    Fxch_CollectSingles( vLitP, vLitN, &p->vCubesS );
//    assert( Vec_IntSize(&p->vCubesS) % 2 == 0 );
    Vec_IntTwoRemoveCommon( vLitP, vLitN, &p->vCubesS );
    Fxch_FilterCubes( p, &p->vCubesS, Lit0, Lit1 );
 
    // collect double-cube-divisor cube pairs
    Fxch_CollectDoubles( p, Vec_WecEntry(&p->vPairs, iDiv), &p->vCubesD, Abc_LitNot(Lit0), Abc_LitNot(Lit1) );
    assert( Vec_IntSize(&p->vCubesD) % 2 == 0 );
    Vec_IntUniqifyPairs( &p->vCubesD );
    assert( Vec_IntSize(&p->vCubesD) % 2 == 0 );
 
    // subtract cost of single-cube divisors
//    Vec_IntForEachEntryDouble( &p->vCubesS, hCube1, hCube2, i )
    Vec_IntForEachEntry( &p->vCubesS, hCube1, i )
        Fxch_TabSingleDivisors( p, Pla_CubeNum(hCube1), 0 );  // remove - update
    Vec_IntForEachEntryDouble( &p->vCubesD, hCube1, hCube2, i )
        Fxch_TabSingleDivisors( p, Pla_CubeNum(hCube1), 0 ),  // remove - update
        Fxch_TabSingleDivisors( p, Pla_CubeNum(hCube2), 0 );  // remove - update
 
    // subtract cost of double-cube divisors
//    Vec_IntForEachEntryDouble( &p->vCubesS, hCube1, hCube2, i )
    Vec_IntForEachEntry( &p->vCubesS, hCube1, i )
    {
        //printf( "%d ", Pla_CubeNum(hCube1) );
        Fxch_TabDoubleDivisors( p, Pla_CubeNum(hCube1), 0 );  // remove - update
    }
    //printf( "\n" );
 
    Vec_IntForEachEntryDouble( &p->vCubesD, hCube1, hCube2, i )
    {
        //printf( "%d ", Pla_CubeNum(hCube1) );
        //printf( "%d  ", Pla_CubeNum(hCube2) );
        Fxch_TabDoubleDivisors( p, Pla_CubeNum(hCube1), 0 ),  // remove - update
        Fxch_TabDoubleDivisors( p, Pla_CubeNum(hCube2), 0 );  // remove - update
    }
    //printf( "\n" );
 
    // create new literals
    p->nLits += 2;
    iVarNew = Vec_WecSize( &p->vLits ) / 2;
    vLitP = Vec_WecPushLevel( &p->vLits );
    vLitN = Vec_WecPushLevel( &p->vLits );
    vLitP = Vec_WecEntry( &p->vLits, Vec_WecSize(&p->vLits) - 2 );
    // update single-cube divisor cubes
//    Vec_IntForEachEntryDouble( &p->vCubesS, hCube1, hCube2, i )
    Vec_IntForEachEntry( &p->vCubesS, hCube1, i )
    {
//        int Lit0s, Lit1s;
        vCube1 = Fxch_ManCube( p, hCube1 );
//        Lit0s = Vec_IntEntry(vCube1, Pla_CubeLit(hCube1));
//        Lit1s = Vec_IntEntry(vCube1, Pla_CubeLit(hCube2));
//        assert( Pla_CubeNum(hCube1) == Pla_CubeNum(hCube2) );
//        assert( Vec_IntEntry(vCube1, Pla_CubeLit(hCube1)) == Lit0 );
//        assert( Vec_IntEntry(vCube1, Pla_CubeLit(hCube2)) == Lit1 );
        Fxch_CompressLiterals( vCube1, Lit0, Lit1 );
//        Vec_IntPush( vLitP, Pla_CubeHandle(Pla_CubeNum(hCube1), Vec_IntSize(vCube1)) );
        Vec_IntPush( vLitP, Pla_CubeNum(hCube1) );
        Vec_IntPush( vCube1, Abc_Var2Lit(iVarNew, 0) );
 
        //if ( Pla_CubeNum(hCube1) == 3 )
        //    printf( "VecSize = %d\n", Vec_IntSize(vCube1) );
 
        p->nLits--;
    }
    // update double-cube divisor cube pairs
    Vec_IntForEachEntryDouble( &p->vCubesD, hCube1, hCube2, i )
    {
        vCube1 = Fxch_ManCube( p, hCube1 );
        vCube2 = Fxch_ManCube( p, hCube2 );
        assert( Vec_IntEntry(vCube1, Pla_CubeLit(hCube1)) == Abc_LitNot(Lit0) );
        assert( Vec_IntEntry(vCube2, Pla_CubeLit(hCube2)) == Abc_LitNot(Lit1) );
        Fxch_CompressLiterals2( vCube1, Pla_CubeLit(hCube1), -1 );
//        Vec_IntPush( vLitN, Pla_CubeHandle(Pla_CubeNum(hCube1), Vec_IntSize(vCube1)) );
        Vec_IntPush( vLitN, Pla_CubeNum(hCube1) );
        Vec_IntPush( vCube1, Abc_Var2Lit(iVarNew, 1) );
        p->nLits -= Vec_IntSize(vCube2);
 
        //if ( Pla_CubeNum(hCube1) == 3 )
        //    printf( "VecSize = %d\n", Vec_IntSize(vCube1) );
 
        // remove second cube
        Vec_IntClear( vCube2 ); 
    }
    Vec_IntSort( vLitN, 0 );
    Vec_IntSort( vLitP, 0 );
 
    // add cost of single-cube divisors
//    Vec_IntForEachEntryDouble( &p->vCubesS, hCube1, hCube2, i )
    Vec_IntForEachEntry( &p->vCubesS, hCube1, i )
        Fxch_TabSingleDivisors( p, Pla_CubeNum(hCube1), 1 );  // add - update
    Vec_IntForEachEntryDouble( &p->vCubesD, hCube1, hCube2, i )
        Fxch_TabSingleDivisors( p, Pla_CubeNum(hCube1), 1 );  // add - update
 
    // add cost of double-cube divisors
//    Vec_IntForEachEntryDouble( &p->vCubesS, hCube1, hCube2, i )
    Vec_IntForEachEntry( &p->vCubesS, hCube1, i )
        Fxch_TabDoubleDivisors( p, Pla_CubeNum(hCube1), 1 );  // add - update
    Vec_IntForEachEntryDouble( &p->vCubesD, hCube1, hCube2, i )
        Fxch_TabDoubleDivisors( p, Pla_CubeNum(hCube1), 1 );  // add - update
    
    // check predicted improvement: (new SOP lits == old SOP lits - divisor weight)
    //assert( p->nLits == nLitsNew );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Fxch_ManWriteBlif()

void Fxch_ManWriteBlif	(	char *	pFileName,
		Vec_Wec_t *	vCubes,
		Vec_Wrd_t *	vDivs )

FUNCTION DEFINITIONS ///.

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

Synopsis [Writes the current state of the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 93 of file plaFxch.c.

{
    // find the number of original variables
    int nVarsInit = Vec_WrdCountZero(vDivs);
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
    else
    {
        //char * pLits = "-01?";
        Vec_Str_t * vStr;
        Vec_Int_t * vCube;
        int i, k, Lit;
        word Div;
        // comment
        fprintf( pFile, "# BLIF file written via PLA package in ABC on " );
        fprintf( pFile, "%s", Extra_TimeStamp() );
        fprintf( pFile, "\n\n" );
        // header
        fprintf( pFile, ".model %s\n", pFileName );
        fprintf( pFile, ".inputs" );
        for ( i = 0; i < nVarsInit; i++ )
            fprintf( pFile, " i%d", i );
        fprintf( pFile, "\n" );
        fprintf( pFile, ".outputs o" );
        fprintf( pFile, "\n" );
        // SOP header
        fprintf( pFile, ".names" );
        for ( i = 0; i < Vec_WrdSize(vDivs); i++ )
            fprintf( pFile, " i%d", i );
        fprintf( pFile, " o\n" );
        // SOP cubes
        vStr = Vec_StrStart( Vec_WrdSize(vDivs) + 1 );
        Vec_WecForEachLevel( vCubes, vCube, i )
        {
            if ( !Vec_IntSize(vCube) )
                continue;
            for ( k = 0; k < Vec_WrdSize(vDivs); k++ )
                Vec_StrWriteEntry( vStr, k, '-' );
            Vec_IntForEachEntry( vCube, Lit, k )
                Vec_StrWriteEntry( vStr, Abc_Lit2Var(Lit), (char)(Abc_LitIsCompl(Lit) ? '0' : '1') );
            fprintf( pFile, "%s 1\n", Vec_StrArray(vStr) );
        }
        Vec_StrFree( vStr );
        // divisors
        Vec_WrdForEachEntryStart( vDivs, Div, i, nVarsInit )
        {
            int pLits[2] = { (int)(Div & 0xFFFFFFFF), (int)(Div >> 32) };
            fprintf( pFile, ".names" );
            fprintf( pFile, " i%d", Abc_Lit2Var(pLits[0]) );
            fprintf( pFile, " i%d", Abc_Lit2Var(pLits[1]) );
            fprintf( pFile, " i%d\n", i );
            fprintf( pFile, "%d%d 1\n", !Abc_LitIsCompl(pLits[0]), !Abc_LitIsCompl(pLits[1]) );
        }
        fprintf( pFile, ".end\n\n" );
        fclose( pFile );
        printf( "Written BLIF file \"%s\".\n", pFileName );
    }
}

Here is the call graph for this function:

◆ Fxch_TabDoubleDivisors()

int Fxch_TabDoubleDivisors	(	Fxch_Man_t *	p,
		int	iCube,
		int	fAdd )

Definition at line 567 of file plaFxch.c.

{
    Vec_Int_t * vCube = Vec_WecEntry( &p->vCubes, iCube );
    int iLinkFirst = Vec_IntEntry( &p->vCubeLinks, iCube );
    int k, Lit, Value = 0;
    Vec_IntForEachEntry( vCube, Lit, k )
        Value += Vec_IntEntry(&p->vRands, Lit);
    Vec_IntForEachEntry( vCube, Lit, k )
    {
        Value -= Vec_IntEntry(&p->vRands, Lit);
        if ( fAdd )
            Fxch_TabInsert( p, iLinkFirst + k, Value, Pla_CubeHandle(iCube, k) );
        else
            Fxch_TabExtract( p, iLinkFirst + k, Value, Pla_CubeHandle(iCube, k) );
        Value += Vec_IntEntry(&p->vRands, Lit);
    }
    return 1;
}

Here is the caller graph for this function:

◆ Fxch_TabSingleDivisors()

int Fxch_TabSingleDivisors	(	Fxch_Man_t *	p,
		int	iCube,
		int	fAdd )

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

Synopsis [Starting the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 550 of file plaFxch.c.

{
    Vec_Int_t * vCube = Vec_WecEntry( &p->vCubes, iCube );
    int i, k, Lit, Lit2;
    if ( Vec_IntSize(vCube) < 2 )
        return 0;
    Vec_IntForEachEntry( vCube, Lit, i )
    Vec_IntForEachEntryStart( vCube, Lit2, k, i+1 )
    {
        assert( Lit < Lit2 );
        if ( fAdd )
            Fxch_DivisorAdd( p, Lit, Lit2, 1 ), p->nPairsS++;
        else
            Fxch_DivisorRemove( p, Lit, Lit2, 1 ), p->nPairsS--;
    }
    return Vec_IntSize(vCube) * (Vec_IntSize(vCube) - 1) / 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Pla_ManPerformFxch()

int Pla_ManPerformFxch ( Pla_Man_t * p )

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

Synopsis [Implements the improved fast_extract algorithm.]

Description []

SideEffects []

SeeAlso []

Definition at line 833 of file plaFxch.c.

{
    char pFileName[1000];
    Fxch_Man_t * pFxch;
    Pla_ManConvertFromBits( p );
    pFxch = Fxch_ManStart( &p->vCubeLits, &p->vOccurs );
    Vec_WecZero( &p->vCubeLits );
    Vec_WecZero( &p->vOccurs );
    Fxch_ManFastExtract( pFxch, 1, 0 );
    sprintf( pFileName, "%s.blif", Pla_ManName(p) );
    //Fxch_ManWriteBlif( pFileName, &pFxch->vCubes, &pFxch->vDivs );
    Fxch_ManStop( pFxch );
    return 1;
}

Here is the call graph for this function:

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ Fxch_ManForEachCubeVec

Typedef Documentation

◆ Fxch_Man_t

◆ Fxch_Obj_t

Function Documentation

◆ Fxch_DivisorAdd()

◆ Fxch_DivisorRemove()

◆ Fxch_ManCreateDivisors()

◆ Fxch_ManFastExtract()

◆ Fxch_ManStart()

◆ Fxch_ManStop()

◆ Fxch_ManUpdate()

◆ Fxch_ManWriteBlif()

◆ Fxch_TabDoubleDivisors()

◆ Fxch_TabSingleDivisors()

◆ Pla_ManPerformFxch()