ioReadPla.c File Reference

#include "ioAbc.h"
#include "misc/util/utilTruth.h"

Include dependency graph for ioReadPla.c:

Go to the source code of this file.

Functions
void	Io_ReadPlaMarkIdentical (word **pCs, int nCubes, int nWords, Vec_Bit_t *vMarks)
void	Io_ReadPlaMarkContained (word **pCs, int nCubes, int nWords, Vec_Bit_t *vMarks)
int	Io_ReadPlaRemoveMarked (word **pCs, int nCubes, int nWords, Vec_Bit_t *vMarks)
int	Io_ReadPlaMergeDistance1 (word **pCs, int nCubes, int nWords, Vec_Bit_t *vMarks)
int	Io_ReadPlaSelfSubsumption (word **pCs, int nCubes, int nWords, Vec_Bit_t *vMarks)
word **	Io_ReadPlaCubeSetup (Vec_Str_t *vSop)
void	Io_ReadPlaCubeSetdown (Vec_Str_t *vSop, word **pCs, int nCubes, int nVars)
void	Io_ReadPlaCubePreprocess (Vec_Str_t *vSop, int iCover, int fVerbose)
Abc_Ntk_t *	Io_ReadPla (char *pFileName, int fZeros, int fBoth, int fOnDc, int fSkipPrepro, int fCheck)

Function Documentation

Io_ReadPla()

Abc_Ntk_t * Io_ReadPla	(	char *	pFileName,
		int	fZeros,
		int	fBoth,
		int	fOnDc,
		int	fSkipPrepro,
		int	fCheck )

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

Synopsis [Reads the network from a PLA file.]

Description []

SideEffects []

SeeAlso []

Definition at line 329 of file ioReadPla.c.

{
    Extra_FileReader_t * p;
    Abc_Ntk_t * pNtk;
 
    // start the file
    p = Extra_FileReaderAlloc( pFileName, "#", "\n\r", " \t|" );
//    p = Extra_FileReaderAlloc( pFileName, "", "\n\r", " \t|" );
    if ( p == NULL )
        return NULL;
 
    // read the network
    pNtk = Io_ReadPlaNetwork( p, fZeros, fBoth, fOnDc, fSkipPrepro );
    Extra_FileReaderFree( p );
    if ( pNtk == NULL )
        return NULL;
 
    // make sure that everything is okay with the network structure
    if ( fCheck && !Abc_NtkCheckRead( pNtk ) )
    {
        printf( "Io_ReadPla: The network check has failed.\n" );
        Abc_NtkDelete( pNtk );
        return NULL;
    }
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Io_ReadPlaCubePreprocess()

void Io_ReadPlaCubePreprocess	(	Vec_Str_t *	vSop,
		int	iCover,
		int	fVerbose )

Definition at line 275 of file ioReadPla.c.

{
    word ** pCs = Io_ReadPlaCubeSetup( vSop );
    int nCubes  = Abc_SopGetCubeNum( Vec_StrArray(vSop) );
    int nVars   = Abc_SopGetVarNum( Vec_StrArray(vSop) );
    int nWords  = Abc_Bit6WordNum( 2*nVars );
    int nCubesNew, Count, Iter = 0;
    Vec_Bit_t * vMarks = Vec_BitStart( nCubes );
    if ( fVerbose )
        printf( "Cover %5d : V =%5d  C%d =%5d", iCover, nVars, Iter, nCubes );
 
    do 
    {
        Iter++;
        do 
        {
            // remove contained
            Io_ReadPlaMarkContained( pCs, nCubes, nWords, vMarks );
            nCubesNew = Io_ReadPlaRemoveMarked( pCs, nCubes, nWords, vMarks );
            //if ( fVerbose )
            //    printf( "  C =%5d", nCubes - nCubesNew );
            nCubes = nCubesNew;
            // merge distance-1
            Count = Io_ReadPlaMergeDistance1( pCs, nCubes, nWords, vMarks );
        } while ( Count );
        if ( fVerbose )
            printf( "  C%d =%5d", Iter, nCubes );
        // try consensus
        //Count = Io_ReadPlaSelfSubsumption( pCs, nCubes, nWords, vMarks );
        if ( fVerbose )
            printf( "%4d", Count );
    } while ( Count );
 
    // translate
    Io_ReadPlaCubeSetdown( vSop, pCs, nCubes, nVars );
    // finalize
    if ( fVerbose )
        printf( "\n" );
    Vec_BitFree( vMarks );
    ABC_FREE( pCs[0] );
    ABC_FREE( pCs );
}

Here is the call graph for this function:

Io_ReadPlaCubeSetdown()

void Io_ReadPlaCubeSetdown	(	Vec_Str_t *	vSop,
		word **	pCs,
		int	nCubes,
		int	nVars )

Definition at line 263 of file ioReadPla.c.

{
    char Symbs[3] = {'-', '0', '1'}; int c, v;
    Vec_StrClear( vSop );
    for ( c = 0; c < nCubes; c++ )
    {
        for ( v = 0; v < nVars; v++ )
            Vec_StrPush( vSop, Symbs[Abc_TtGetQua(pCs[c], v)] );
        Vec_StrPrintStr( vSop, " 1\n" );
    }
    Vec_StrPush( vSop, 0 );
}

Here is the caller graph for this function:

Io_ReadPlaCubeSetup()

word ** Io_ReadPlaCubeSetup

(

Vec_Str_t *

vSop

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 240 of file ioReadPla.c.

{
    char * pSop = Vec_StrArray( vSop ), * pCube, Lit;
    int nCubes  = Abc_SopGetCubeNum( pSop );
    int nVars   = Abc_SopGetVarNum( pSop );
    int nWords  = Abc_Bit6WordNum( 2*nVars ), c, v;
    word ** pCs = ABC_ALLOC( word *, nCubes );
    pCs[0] = ABC_CALLOC( word, nCubes * nWords );
    for ( c = 1; c < nCubes; c++ )
        pCs[c] = pCs[c-1] + nWords;
    c = 0;
    Abc_SopForEachCube( pSop, nVars, pCube )
    {
        Abc_CubeForEachVar( pCube, Lit, v )
            if ( Lit == '0' )
                Abc_TtSetBit( pCs[c], Abc_Var2Lit(v,0) );
            else if ( Lit == '1' )
                Abc_TtSetBit( pCs[c], Abc_Var2Lit(v,1) );
        c++;
    }
    assert( c == nCubes );
    return pCs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Io_ReadPlaMarkContained()

void Io_ReadPlaMarkContained	(	word **	pCs,
		int	nCubes,
		int	nWords,
		Vec_Bit_t *	vMarks )

Definition at line 127 of file ioReadPla.c.

{
    int c1, c2;
    Vec_BitFill( vMarks, nCubes, 0 );
    for ( c1 = 0; c1 < nCubes; c1++ )
        if ( !Vec_BitEntry(vMarks, c1) )
            for ( c2 = c1 + 1; c2 < nCubes; c2++ )
                if ( !Vec_BitEntry(vMarks, c2) )
                {
                    if ( Abc_TtImply(pCs[c1], pCs[c2], nWords) )
                        Vec_BitWriteEntry( vMarks, c2, 1 );
                    else if ( Abc_TtImply(pCs[c2], pCs[c1], nWords) )
                    {
                        Vec_BitWriteEntry( vMarks, c1, 1 );
                        break;
                    }
                }
}

Here is the caller graph for this function:

Io_ReadPlaMarkIdentical()

void Io_ReadPlaMarkIdentical	(	word **	pCs,
		int	nCubes,
		int	nWords,
		Vec_Bit_t *	vMarks )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 116 of file ioReadPla.c.

{
    int c1, c2;
    Vec_BitFill( vMarks, nCubes, 0 );
    for ( c1 = 0; c1 < nCubes; c1++ )
        if ( !Vec_BitEntry(vMarks, c1) )
            for ( c2 = c1 + 1; c2 < nCubes; c2++ )
                if ( !Vec_BitEntry(vMarks, c2) )
                    if ( Abc_TtEqual(pCs[c1], pCs[c2], nWords) )
                        Vec_BitWriteEntry( vMarks, c2, 1 );
}

Io_ReadPlaMergeDistance1()

int Io_ReadPlaMergeDistance1	(	word **	pCs,
		int	nCubes,
		int	nWords,
		Vec_Bit_t *	vMarks )

Definition at line 158 of file ioReadPla.c.

{
    int c1, c2, Res, Counter = 0;
    Vec_BitFill( vMarks, nCubes, 0 );
    for ( c1 = 0; c1 < nCubes; c1++ )
        if ( !Vec_BitEntry(vMarks, c1) )
            for ( c2 = c1 + 1; c2 < nCubes; c2++ )
                if ( !Vec_BitEntry(vMarks, c2) )
                {
                    Res = Io_ReadPlaDistance1( pCs[c1], pCs[c2], nWords );
                    if ( !Res )
                        continue;
                    Abc_TtAnd( pCs[c1], pCs[c1], pCs[c2], nWords, 0 );
                    Vec_BitWriteEntry( vMarks, c2, 1 );
                    Counter++;
                    break;
                }
    return Counter;
}

Here is the caller graph for this function:

Io_ReadPlaRemoveMarked()

int Io_ReadPlaRemoveMarked	(	word **	pCs,
		int	nCubes,
		int	nWords,
		Vec_Bit_t *	vMarks )

Definition at line 145 of file ioReadPla.c.

{
    int c1, c;
    for ( c1 = c = 0; c1 < nCubes; c1++ )
        if ( !Vec_BitEntry(vMarks, c1) )
        {
            if ( c == c1 )
                c++;
            else
                Abc_TtCopy( pCs[c++], pCs[c1], nWords, 0 );
        }
    return c;
}

Here is the caller graph for this function:

Io_ReadPlaSelfSubsumption()

int Io_ReadPlaSelfSubsumption	(	word **	pCs,
		int	nCubes,
		int	nWords,
		Vec_Bit_t *	vMarks )

Definition at line 177 of file ioReadPla.c.

{
    int c1, c2, Res, Counter = 0, iVar = -1, Val0, Val1;
    Vec_BitFill( vMarks, nCubes, 0 );
    for ( c1 = 0; c1 < nCubes; c1++ )
        if ( !Vec_BitEntry(vMarks, c1) )
            for ( c2 = c1 + 1; c2 < nCubes; c2++ )
                if ( !Vec_BitEntry(vMarks, c2) )
                {
                    Res = Io_ReadPlaConsensus( pCs[c1], pCs[c2], nWords, &iVar );
                    if ( !Res )
                        continue;
                    assert( iVar >= 0  && iVar < nWords*32 );
                    Val0 = Abc_TtGetQua( pCs[c1], iVar );
                    Val1 = Abc_TtGetQua( pCs[c2], iVar );
                    // remove values
                    Abc_TtXorQua( pCs[c1], iVar, Val0 );
                    Abc_TtXorQua( pCs[c2], iVar, Val1 );
                    // check containment
                    if ( Abc_TtImply(pCs[c1], pCs[c2], nWords) )
                    {
                        Abc_TtXorQua( pCs[c1], iVar, Val0 );
                        Vec_BitWriteEntry( vMarks, c2, 1 );
                        Counter++;
                    }
                    else if ( Abc_TtImply(pCs[c2], pCs[c1], nWords) )
                    {
                        Abc_TtXorQua( pCs[c2], iVar, Val1 );
                        Vec_BitWriteEntry( vMarks, c1, 1 );
                        Counter++;
                        break;
                    }
                    else
                    {
                        Abc_TtXorQua( pCs[c1], iVar, Val0 );
                        Abc_TtXorQua( pCs[c2], iVar, Val1 );
                    }
 
/*
                    printf( "Var = %3d  ", iVar );
                    printf( "Cube0 = %d  ", Abc_TtGetQua(pCs[c1], iVar) );
                    printf( "Cube1 = %d  ", Abc_TtGetQua(pCs[c2], iVar) );
                    printf( "\n" );
                    Io_ReadPlaPrintCube( pCs[c1], 32 * nWords );
                    Io_ReadPlaPrintCube( pCs[c2], 32 * nWords );
                    printf( "\n" );
*/
                    break;
                }
    return Counter;
}