plaMan.c File Reference

#include "pla.h"

Include dependency graph for plaMan.c:

Go to the source code of this file.

Functions
ABC_NAMESPACE_IMPL_START void	Pla_GenSorter (int nVars)
	DECLARATIONS ///.
Vec_Bit_t *	Pla_ManPrimesTable (int nVars)
Vec_Int_t *	Pla_GenPrimes (int nVars)
Pla_Man_t *	Pla_GenFromMinterms (char *pName, Vec_Int_t *vMints, int nVars)
Pla_Man_t *	Pla_ManPrimesDetector (int nVars)
Vec_Bit_t *	Pla_GenRandom (int nVars, int nNums, int fNonZero)
Pla_Man_t *	Pla_ManGenerate (int nInputs, int nOutputs, int nCubes, int fVerbose)
void	Pla_ManConvertFromBits (Pla_Man_t *p)
void	Pla_ManConvertToBits (Pla_Man_t *p)
int	Pla_ManDist1Num (Pla_Man_t *p)
int	Pla_ManDist1NumTest (Pla_Man_t *p)

Function Documentation

Pla_GenFromMinterms()

Pla_Man_t * Pla_GenFromMinterms	(	char *	pName,
		Vec_Int_t *	vMints,
		int	nVars )

Definition at line 113 of file plaMan.c.

{
    Pla_Man_t * p = Pla_ManAlloc( pName, nVars, 1, Vec_IntSize(vMints) );
    int i, k, Lit, Mint;
    word * pCube;
    Pla_ForEachCubeIn( p, pCube, i )
    {
        Mint = Vec_IntEntry(vMints, i);
        Pla_CubeForEachLitIn( p, pCube, Lit, k )
            Pla_CubeSetLit( pCube, k, ((Mint >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
    }
    Pla_ForEachCubeOut( p, pCube, i )
        Pla_CubeSetLit( pCube, 0, PLA_LIT_ONE );
    return p;
}

Here is the caller graph for this function:

Pla_GenPrimes()

Vec_Int_t * Pla_GenPrimes

(

int

nVars

)

Definition at line 100 of file plaMan.c.

{
    int n, nBits = ( 1 << nVars );
    Vec_Int_t * vPrimes = Vec_IntAlloc( 1000 );
    Vec_Bit_t * vMap = Pla_ManPrimesTable( nVars );
    for ( n = 2; n < nBits; n++ )
        if ( Vec_BitEntry(vMap, n) )
            Vec_IntPush( vPrimes, n );
    printf( "Primes up to 2^%d = %d\n", nVars, Vec_IntSize(vPrimes) );
//    Abc_GenCountHits1( vMap, vPrimes, nVars );
    Vec_BitFree( vMap );
    return vPrimes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Pla_GenRandom()

Vec_Bit_t * Pla_GenRandom	(	int	nVars,
		int	nNums,
		int	fNonZero )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 150 of file plaMan.c.

{
    int Mint, Count = 0;
    Vec_Bit_t * vBits = Vec_BitStart( 1 << nVars );
    assert( nVars > 0 && nVars <= 30 );
    assert( nNums > 0 && nNums < (1 << (nVars - 1)) );
    while ( Count < nNums )
    {
        Mint = Gia_ManRandom(0) & ((1 << nVars) - 1);
        if ( fNonZero && Mint == 0 )
            continue;
        if ( Vec_BitEntry(vBits, Mint) )
            continue;
        Vec_BitWriteEntry( vBits, Mint, 1 );
        Count++;
    }
    return vBits;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Pla_GenSorter()

ABC_NAMESPACE_IMPL_START void Pla_GenSorter

(

int

nVars

)

DECLARATIONS ///.

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

FileName [plaMan.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

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Generates PLA description of a sorter.]

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file plaMan.c.

{
    int i, k, Count, nMints = ( 1 << nVars );
    char Buffer[20];
    FILE * pFile;
    sprintf( Buffer, "sorter%02d.pla", nVars );
    pFile = fopen( Buffer, "wb" );
    fprintf( pFile, "# This file was generated by ABC on %s.\n", Extra_TimeStamp() );
    fprintf( pFile, ".i %d\n", nVars );
    fprintf( pFile, ".o %d\n", nVars );
    fprintf( pFile, ".p %d\n", nMints-1 );
    for ( i = 1; i < nMints; i++ )
    {
        Count = 0;
        for ( k = nVars-1; k >= 0; k-- )
        {
            Count += ((i >> k) & 1);
            fprintf( pFile, "%d", (i >> k) & 1 );
        }
        fprintf( pFile, " " );
        for ( k = 0; k < Count; k++ )
            fprintf( pFile, "1" );
        for (      ; k < nVars; k++ )
            fprintf( pFile, "0" );
        fprintf( pFile, "\n" );
    }
    fprintf( pFile, ".end\n" );
    fclose( pFile );
}

Here is the call graph for this function:

Pla_ManConvertFromBits()

void Pla_ManConvertFromBits

(

Pla_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 221 of file plaMan.c.

{
    Vec_Int_t * vCube;
    word * pCube; int i, k, Lit, Count;
    Vec_WecClear( &p->vCubeLits );
    Vec_WecClear( &p->vOccurs );
    Vec_WecInit( &p->vCubeLits, Pla_ManCubeNum(p) );
    Vec_WecInit( &p->vOccurs, 2*Pla_ManInNum(p) );
    Pla_ForEachCubeIn( p, pCube, i )
    {
        vCube = Vec_WecEntry( &p->vCubeLits, i );
 
        Count = 0;
        Pla_CubeForEachLitIn( p, pCube, Lit, k )
            if ( Lit != PLA_LIT_DASH )
                Count++;
        Vec_IntGrow( vCube, Count );
 
        Count = 0;
        Pla_CubeForEachLitIn( p, pCube, Lit, k )
            if ( Lit != PLA_LIT_DASH )
            {
                Lit = Abc_Var2Lit( k, Lit == PLA_LIT_ZERO );
                Vec_WecPush( &p->vCubeLits, i, Lit );
//                Vec_WecPush( &p->vOccurs, Lit, Pla_CubeHandle(i, Count++) );
                Vec_WecPush( &p->vOccurs, Lit, i );
            }
        assert( Vec_IntSize(vCube) == Vec_IntCap(vCube) );
    }
}

Here is the caller graph for this function:

Pla_ManConvertToBits()

void Pla_ManConvertToBits

(

Pla_Man_t *

p

)

Definition at line 251 of file plaMan.c.

{
    Vec_Int_t * vCube; int i, k, Lit;
    Vec_IntFillNatural( &p->vCubes, Vec_WecSize(&p->vCubeLits) );
    Vec_WrdFill( &p->vInBits,  Pla_ManCubeNum(p) * p->nInWords,  0 );
    Vec_WecForEachLevel( &p->vCubeLits, vCube, i )
        Vec_IntForEachEntry( vCube, Lit, k )
            Pla_CubeSetLit( Pla_CubeIn(p, i), Abc_Lit2Var(Lit), Abc_LitIsCompl(Lit) ? PLA_LIT_ZERO : PLA_LIT_ONE );
}

Pla_ManDist1Num()

int Pla_ManDist1Num

(

Pla_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 272 of file plaMan.c.

{
    word * pCube1, * pCube2; 
    int i, k, Dist, Count = 0;
    Pla_ForEachCubeIn( p, pCube1, i )
    Pla_ForEachCubeInStart( p, pCube2, k, i+1 )
    {
        Dist = Pla_CubesAreDistance1( pCube1, pCube2, p->nInWords );
//        Dist = Pla_CubesAreConsensus( pCube1, pCube2, p->nInWords, NULL );
        Count += (Dist == 1);
    }
    return Count;
}

Here is the caller graph for this function:

Pla_ManDist1NumTest()

int Pla_ManDist1NumTest

(

Pla_Man_t *

p

)

Definition at line 285 of file plaMan.c.

{
    abctime clk = Abc_Clock();
    int Count = Pla_ManDist1Num( p );
    printf( "Found %d pairs among %d cubes using cube pair enumeration.  ", Count, Pla_ManCubeNum(p) );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    return 1;
}

Here is the call graph for this function:

Pla_ManGenerate()

Pla_Man_t * Pla_ManGenerate	(	int	nInputs,
		int	nOutputs,
		int	nCubes,
		int	fVerbose )

Definition at line 168 of file plaMan.c.

{
    Pla_Man_t * p;
    Vec_Bit_t * vBits;
    int i, k, Count;
    word * pCube;
    char Buffer[1000];
    sprintf( Buffer, "%s_%d_%d_%d", "rand", nInputs, nOutputs, nCubes );
    p = Pla_ManAlloc( Buffer, nInputs, nOutputs, nCubes );
    // generate nCube random input minterms
    vBits = Pla_GenRandom( nInputs, nCubes, 0 );
    for ( i = Count = 0; i < Vec_BitSize(vBits); i++ )
        if ( Vec_BitEntry(vBits, i) )
        {
            pCube = Pla_CubeIn( p, Count++ );
            for ( k = 0; k < nInputs; k++ )
                Pla_CubeSetLit( pCube, k, ((i >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
        }
    assert( Count == nCubes );
    Vec_BitFree( vBits );
    // generate nCube random output minterms
    if ( nOutputs > 1 )
    {
        vBits = Pla_GenRandom( nOutputs, nCubes, 1 );
        for ( i = Count = 0; i < Vec_BitSize(vBits); i++ )
            if ( Vec_BitEntry(vBits, i) )
            {
                pCube = Pla_CubeOut( p, Count++ );
                for ( k = 0; k < nOutputs; k++ )
                    Pla_CubeSetLit( pCube, k, ((i >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
            }
        assert( Count == nCubes );
        Vec_BitFree( vBits );
    }
    else
    {
        Pla_ForEachCubeOut( p, pCube, i )
            Pla_CubeSetLit( pCube, 0, PLA_LIT_ONE );
    }
    return p;
}

Here is the call graph for this function:

Pla_ManPrimesDetector()

Pla_Man_t * Pla_ManPrimesDetector

(

int

nVars

)

Definition at line 128 of file plaMan.c.

{
    char pName[1000];
    Pla_Man_t * p;
    Vec_Int_t * vMints = Pla_GenPrimes( nVars );
    sprintf( pName, "primes%02d", nVars );
    p = Pla_GenFromMinterms( pName, vMints, nVars );
    Vec_IntFree( vMints );
    return p;
}

Here is the call graph for this function:

Pla_ManPrimesTable()

Vec_Bit_t * Pla_ManPrimesTable

(

int

nVars

)

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

Synopsis [Generates prime detector for the given bit-widths.]

Description []

SideEffects []

SeeAlso []

Definition at line 85 of file plaMan.c.

{
    int i, n, nBits = 1 << nVars;
    Vec_Bit_t * vMap = Vec_BitStartFull( Abc_MaxInt(64, nBits) );
    for ( i = nBits; i < 64; i++ )
        Vec_BitWriteEntry( vMap, i, 0 );
    Vec_BitShrink( vMap, nBits );
    Vec_BitWriteEntry( vMap, 0, 0 );
    Vec_BitWriteEntry( vMap, 1, 0 );
    for ( n = 2; n < nBits; n++ )
        if ( Vec_BitEntry(vMap, n) )
            for ( i = 2*n; i < nBits; i += n )
                Vec_BitWriteEntry( vMap, i, 0 );
    return vMap;
}

Here is the caller graph for this function: