abcRpo.c File Reference

#include "misc/extra/extra.h"
#include "bool/rpo/rpo.h"
#include "bool/rpo/literal.h"

Include dependency graph for abcRpo.c:

Go to the source code of this file.

Classes
struct	Rpo_TtStore_t_

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Rpo_TtStore_t_	Rpo_TtStore_t

Functions
int	Abc_FileSize (char *pFileName)
char *	Abc_FileRead (char *pFileName)
void	Abc_TruthGetParams (char *pFileName, int *pnVars, int *pnTruths)
void	Abc_TruthRpoPerform (Rpo_TtStore_t *p, int nThreshold, int fVerbose)
void	Abc_TruthRpoTest (char *pFileName, int nVarNum, int nThreshold, int fVerbose)
int	Abc_RpoTest (char *pFileName, int nVarNum, int nThreshold, int fVerbose)

Typedef Documentation

Rpo_TtStore_t

typedef typedefABC_NAMESPACE_IMPL_START struct Rpo_TtStore_t_ Rpo_TtStore_t

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

FileName [abcRpo.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Rpo package.]

Synopsis [Procedures for executing RPO.]

Author [Mayler G. A. Martins / Vinicius Callegaro]

Affiliation [UFRGS]

Date [Ver. 1.0. Started - May 08, 2013.]

Revision [

Id

abcRpo.c,v 1.00 2013/05/08 00:00:00 mgamartins Exp

]

Definition at line 30 of file abcRpo.c.

Function Documentation

Abc_FileRead()

char * Abc_FileRead ( char * pFileName )

extern

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

Synopsis [Read file contents.]

Description []

SideEffects []

SeeAlso []

Definition at line 223 of file abcDec.c.

{
    FILE * pFile;
    char * pBuffer;
    int nFileSize, RetValue;
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
        return NULL;
    }
    // get the file size, in bytes
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile );  
    // move the file current reading position to the beginning
    rewind( pFile ); 
    // load the contents of the file into memory
    pBuffer = (char *)malloc( nFileSize + 3 );
    RetValue = fread( pBuffer, nFileSize, 1, pFile );
    // add several empty lines at the end
    // (these will be used to signal the end of parsing)
    pBuffer[ nFileSize + 0] = '\n';
    pBuffer[ nFileSize + 1] = '\n';
    // terminate the string with '\0'
    pBuffer[ nFileSize + 2] = '\0';
    fclose( pFile );
    return pBuffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FileSize()

int Abc_FileSize ( char * pFileName )

extern

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

Synopsis [Read file contents.]

Description []

SideEffects []

SeeAlso []

Definition at line 195 of file abcDec.c.

{
    FILE * pFile;
    int nFileSize;
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
        return -1;
    }
    // get the file size, in bytes
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile );  
    fclose( pFile );
    return nFileSize;
}

Here is the caller graph for this function:

Abc_RpoTest()

int Abc_RpoTest	(	char *	pFileName,
		int	nVarNum,
		int	nThreshold,
		int	fVerbose )

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

Synopsis [Testbench for decomposition algorithms.]

Description []

SideEffects []

SeeAlso []

Definition at line 425 of file abcRpo.c.

                                                                            {
    if (fVerbose) {
        printf("Using truth tables from file \"%s\"...\n", pFileName);
    }
    Abc_TruthRpoTest(pFileName, nVarNum, nThreshold, fVerbose);
    fflush(stdout);
    return 0;
}

Here is the call graph for this function:

Abc_TruthGetParams()

void Abc_TruthGetParams ( char * pFileName, int * pnVars, int * pnTruths )

extern

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

Synopsis [Determine the number of variables by reading the first line.]

Description [Determine the number of functions by counting the lines.]

SideEffects []

SeeAlso []

Definition at line 263 of file abcDec.c.

{
    char * pContents;
    int i, nVars, nLines;
    // prepare the output 
    if ( pnVars )
        *pnVars = 0;
    if ( pnTruths )
        *pnTruths = 0;
    // read data from file
    pContents = Abc_FileRead( pFileName );
    if ( pContents == NULL )
        return;
    // count the number of symbols before the first space or new-line
    // (note that on Windows symbols '\r' can be inserted before each '\n')
    for ( i = 0; pContents[i]; i++ )
        if ( pContents[i] == ' ' || pContents[i] == '\n' || pContents[i] == '\r' )
            break;
    if ( pContents[i] == 0 )
        printf( "Strange, the input file does not have spaces and new-lines...\n" );
 
    // acount for the fact that truth tables may have "0x" at the beginning of each line
    if ( pContents[0] == '0' && pContents[1] == 'x' )
        i = i - 2;
 
    // determine the number of variables
    for ( nVars = 0; nVars < 32; nVars++ )
        if ( 4 * i == (1 << nVars) ) // the number of bits equal to the size of truth table
            break;
    if ( nVars < 2 || nVars > 16 )
    {
        printf( "Does not look like the input file contains truth tables...\n" );
        return;
    }
    if ( pnVars )
        *pnVars = nVars;
 
    // determine the number of functions by counting the lines
    nLines = 0;
    for ( i = 0; pContents[i]; i++ )
        nLines += (pContents[i] == '\n');
    if ( pnTruths )
        *pnTruths = nLines;
    ABC_FREE( pContents );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_TruthRpoPerform()

void Abc_TruthRpoPerform	(	Rpo_TtStore_t *	p,
		int	nThreshold,
		int	fVerbose )

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

Synopsis [Apply decomposition to the truth table.]

Description [Returns the number of AIG nodes.]

SideEffects []

SeeAlso []

Definition at line 345 of file abcRpo.c.

                                                                          {
    clock_t clk = clock();
    int i;
    int rpoCount = 0;
    Literal_t* lit;
    float percent;
    for (i = 0; i < p->nFuncs; i++) {
//        if(i>1000) {
//            continue;
//        }
//        if(i!= 2196 ) { //5886
//            continue;
//        }
        if(fVerbose) {
            Abc_Print(-2,"%d: ", i+1);
        }
            
        lit = Rpo_Factorize((unsigned *) p->pFuncs[i], p->nVars, nThreshold, fVerbose);
        if (lit != NULL) {
            if(fVerbose) {
                Abc_Print(-2, "Solution : %s\n", lit->expression->pArray);
                Abc_Print(-2, "\n\n");
            }
            Lit_Free(lit);
            rpoCount++;
        } else {
            if(fVerbose) {
                Abc_Print(-2, "null\n");
                Abc_Print(-2, "\n\n");
            }
        }
    }
    percent = (rpoCount * 100.0) / p->nFuncs;
    Abc_Print(-2,"%d of %d (%.2f %%) functions are RPO.\n", rpoCount,p->nFuncs,percent);
    Abc_PrintTime(1, "Time", clock() - clk);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_TruthRpoTest()

void Abc_TruthRpoTest	(	char *	pFileName,
		int	nVarNum,
		int	nThreshold,
		int	fVerbose )

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

Synopsis [Apply decomposition to truth tables.]

Description []

SideEffects []

SeeAlso []

Definition at line 394 of file abcRpo.c.

                                                                                   {
    Rpo_TtStore_t * p;
 
    // allocate data-structure
//    if (fVerbose) {
//        Abc_Print(-2, "Number of variables = %d\n", nVarNum);
//    }
    p = Abc_TtStoreLoad(pFileName, nVarNum);
 
    if (fVerbose) {
        Abc_Print(-2, "Number of variables = %d\n", p->nVars);
    }
    // consider functions from the file
    Abc_TruthRpoPerform(p, nThreshold, fVerbose);
 
    // delete data-structure
    Abc_TtStoreFree(p, nVarNum);
    //    printf( "Finished decomposing truth tables from file \"%s\".\n", pFileName );
}

Here is the call graph for this function:

Here is the caller graph for this function: