mirror of
https://github.com/YosysHQ/abc.git
synced 2026-09-04 00:31:14 +02:00
Bruno Schmitt
3cf495c831
Removes old partial implementation of this algorithm from the "pla" module.
298 lines
12 KiB
C
298 lines
12 KiB
C
/**CFile****************************************************************
|
|
|
|
FileName [pla.h]
|
|
|
|
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: pla.h,v 1.00 2014/09/12 00:00:00 alanmi Exp $]
|
|
|
|
***********************************************************************/
|
|
|
|
#ifndef ABC__base__wlc__wlc_h
|
|
#define ABC__base__wlc__wlc_h
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// INCLUDES ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "aig/gia/gia.h"
|
|
#include "misc/extra/extra.h"
|
|
#include "base/main/mainInt.h"
|
|
//#include "misc/util/utilTruth.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// PARAMETERS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
ABC_NAMESPACE_HEADER_START
|
|
|
|
#define MASK55 ABC_CONST(0x5555555555555555)
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// BASIC TYPES ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
// file types
|
|
typedef enum {
|
|
PLA_FILE_FD = 0,
|
|
PLA_FILE_F,
|
|
PLA_FILE_FR,
|
|
PLA_FILE_FDR,
|
|
PLA_FILE_NONE
|
|
} Pla_File_t;
|
|
|
|
// literal types
|
|
typedef enum {
|
|
PLA_LIT_DASH = 0,
|
|
PLA_LIT_ZERO,
|
|
PLA_LIT_ONE,
|
|
PLA_LIT_FULL
|
|
} Pla_Lit_t;
|
|
|
|
|
|
typedef struct Pla_Man_t_ Pla_Man_t;
|
|
struct Pla_Man_t_
|
|
{
|
|
char * pName; // model name
|
|
char * pSpec; // input file
|
|
Pla_File_t Type; // file type
|
|
int nIns; // inputs
|
|
int nOuts; // outputs
|
|
int nInWords; // words of input data
|
|
int nOutWords; // words of output data
|
|
Vec_Int_t vCubes; // cubes
|
|
Vec_Int_t vHashes; // hash values
|
|
Vec_Wrd_t vInBits; // input bits
|
|
Vec_Wrd_t vOutBits; // output bits
|
|
Vec_Wec_t vCubeLits; // cubes as interger arrays
|
|
Vec_Wec_t vOccurs; // occurence counters for the literals
|
|
Vec_Int_t vDivs; // divisor definitions
|
|
};
|
|
|
|
static inline char * Pla_ManName( Pla_Man_t * p ) { return p->pName; }
|
|
static inline int Pla_ManInNum( Pla_Man_t * p ) { return p->nIns; }
|
|
static inline int Pla_ManOutNum( Pla_Man_t * p ) { return p->nOuts; }
|
|
static inline int Pla_ManCubeNum( Pla_Man_t * p ) { return Vec_IntSize( &p->vCubes ); }
|
|
static inline int Pla_ManDivNum( Pla_Man_t * p ) { return Vec_IntSize( &p->vDivs ); }
|
|
|
|
static inline word * Pla_CubeIn( Pla_Man_t * p, int i ) { return Vec_WrdEntryP(&p->vInBits, i * p->nInWords); }
|
|
static inline word * Pla_CubeOut( Pla_Man_t * p, int i ) { return Vec_WrdEntryP(&p->vOutBits, i * p->nOutWords); }
|
|
|
|
static inline int Pla_CubeNum( int hCube ) { return hCube >> 8; }
|
|
static inline int Pla_CubeLit( int hCube ) { return hCube & 0xFF; }
|
|
static inline int Pla_CubeHandle( int iCube, int iLit ) { assert( !(iCube >> 24) && !(iLit >> 8) ); return iCube << 8 | iLit; }
|
|
|
|
// read/write/flip i-th bit of a bit string table
|
|
static inline int Pla_TtGetBit( word * p, int i ) { return (int)(p[i>>6] >> (i & 63)) & 1; }
|
|
static inline void Pla_TtSetBit( word * p, int i ) { p[i>>6] |= (((word)1)<<(i & 63)); }
|
|
static inline void Pla_TtXorBit( word * p, int i ) { p[i>>6] ^= (((word)1)<<(i & 63)); }
|
|
|
|
// read/write/flip i-th literal in a cube
|
|
static inline int Pla_CubeGetLit( word * p, int i ) { return (int)(p[i>>5] >> ((i<<1) & 63)) & 3; }
|
|
static inline void Pla_CubeSetLit( word * p, int i, Pla_Lit_t d ) { p[i>>5] |= (((word)d)<<((i<<1) & 63)); }
|
|
static inline void Pla_CubeXorLit( word * p, int i, Pla_Lit_t d ) { p[i>>5] ^= (((word)d)<<((i<<1) & 63)); }
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// MACRO DEFINITIONS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// ITERATORS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#define Pla_ForEachCubeIn( p, pCube, i ) \
|
|
for ( i = 0; (i < Pla_ManCubeNum(p)) && (((pCube) = Pla_CubeIn(p, i)), 1); i++ )
|
|
#define Pla_ForEachCubeInStart( p, pCube, i, Start ) \
|
|
for ( i = Start; (i < Pla_ManCubeNum(p)) && (((pCube) = Pla_CubeIn(p, i)), 1); i++ )
|
|
|
|
#define Pla_ForEachCubeOut( p, pCube, i ) \
|
|
for ( i = 0; (i < Pla_ManCubeNum(p)) && (((pCube) = Pla_CubeOut(p, i)), 1); i++ )
|
|
#define Pla_ForEachCubeInOut( p, pCubeIn, pCubeOut, i ) \
|
|
for ( i = 0; (i < Pla_ManCubeNum(p)) && (((pCubeIn) = Pla_CubeIn(p, i)), 1) && (((pCubeOut) = Pla_CubeOut(p, i)), 1); i++ )
|
|
|
|
#define Pla_CubeForEachLit( nVars, pCube, Lit, i ) \
|
|
for ( i = 0; (i < nVars) && (((Lit) = Pla_CubeGetLit(pCube, i)), 1); i++ )
|
|
#define Pla_CubeForEachLitIn( p, pCube, Lit, i ) \
|
|
Pla_CubeForEachLit( Pla_ManInNum(p), pCube, Lit, i )
|
|
#define Pla_CubeForEachLitOut( p, pCube, Lit, i ) \
|
|
Pla_CubeForEachLit( Pla_ManOutNum(p), pCube, Lit, i )
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// FUNCTION DECLARATIONS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis [Checks if cubes are distance-1.]
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
static inline int Pla_OnlyOneOne( word t )
|
|
{
|
|
return t ? ((t & (t-1)) == 0) : 0;
|
|
}
|
|
static inline int Pla_CubesAreDistance1( word * p, word * q, int nWords )
|
|
{
|
|
word Test; int c, fFound = 0;
|
|
for ( c = 0; c < nWords; c++ )
|
|
{
|
|
if ( p[c] == q[c] )
|
|
continue;
|
|
if ( fFound )
|
|
return 0;
|
|
// check if the number of 1s is one, which means exactly one different literal (0/1, -/1, -/0)
|
|
Test = ((p[c] ^ q[c]) | ((p[c] ^ q[c]) >> 1)) & MASK55;
|
|
if ( !Pla_OnlyOneOne(Test) )
|
|
return 0;
|
|
fFound = 1;
|
|
}
|
|
return fFound;
|
|
}
|
|
static inline int Pla_CubesAreConsensus( word * p, word * q, int nWords, int * piVar )
|
|
{
|
|
word Test; int c, fFound = 0;
|
|
for ( c = 0; c < nWords; c++ )
|
|
{
|
|
if ( p[c] == q[c] )
|
|
continue;
|
|
if ( fFound )
|
|
return 0;
|
|
// check if the number of 1s is one, which means exactly one opposite literal (0/1) but may have other diffs (-/0 or -/1)
|
|
Test = ((p[c] ^ q[c]) & ((p[c] ^ q[c]) >> 1)) & MASK55;
|
|
if ( !Pla_OnlyOneOne(Test) )
|
|
return 0;
|
|
fFound = 1;
|
|
if ( piVar ) *piVar = c * 32 + Abc_Tt6FirstBit(Test)/2;
|
|
}
|
|
return fFound;
|
|
}
|
|
static inline int Pla_TtCountOnesOne( word x )
|
|
{
|
|
x = x - ((x >> 1) & ABC_CONST(0x5555555555555555));
|
|
x = (x & ABC_CONST(0x3333333333333333)) + ((x >> 2) & ABC_CONST(0x3333333333333333));
|
|
x = (x + (x >> 4)) & ABC_CONST(0x0F0F0F0F0F0F0F0F);
|
|
x = x + (x >> 8);
|
|
x = x + (x >> 16);
|
|
x = x + (x >> 32);
|
|
return (int)(x & 0xFF);
|
|
}
|
|
static inline int Pla_TtCountOnes( word * p, int nWords )
|
|
{
|
|
int i, Count = 0;
|
|
for ( i = 0; i < nWords; i++ )
|
|
Count += Pla_TtCountOnesOne( p[i] );
|
|
return Count;
|
|
}
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis [Manager APIs.]
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
static inline Pla_Man_t * Pla_ManAlloc( char * pFileName, int nIns, int nOuts, int nCubes )
|
|
{
|
|
Pla_Man_t * p = ABC_CALLOC( Pla_Man_t, 1 );
|
|
p->pName = Extra_FileDesignName( pFileName );
|
|
p->pSpec = Abc_UtilStrsav( pFileName );
|
|
p->nIns = nIns;
|
|
p->nOuts = nOuts;
|
|
p->nInWords = Abc_Bit6WordNum( 2*nIns );
|
|
p->nOutWords = Abc_Bit6WordNum( 2*nOuts );
|
|
Vec_IntFillNatural( &p->vCubes, nCubes );
|
|
Vec_WrdFill( &p->vInBits, Pla_ManCubeNum(p) * p->nInWords, 0 );
|
|
Vec_WrdFill( &p->vOutBits, Pla_ManCubeNum(p) * p->nOutWords, 0 );
|
|
return p;
|
|
}
|
|
static inline void Pla_ManFree( Pla_Man_t * p )
|
|
{
|
|
Vec_IntErase( &p->vCubes );
|
|
Vec_IntErase( &p->vHashes );
|
|
Vec_WrdErase( &p->vInBits );
|
|
Vec_WrdErase( &p->vOutBits );
|
|
Vec_WecErase( &p->vCubeLits );
|
|
Vec_WecErase( &p->vOccurs );
|
|
Vec_IntErase( &p->vDivs );
|
|
ABC_FREE( p->pName );
|
|
ABC_FREE( p->pSpec );
|
|
ABC_FREE( p );
|
|
}
|
|
static inline int Pla_ManLitInNum( Pla_Man_t * p )
|
|
{
|
|
word * pCube; int i, k, Lit, Count = 0;
|
|
Pla_ForEachCubeIn( p, pCube, i )
|
|
Pla_CubeForEachLitIn( p, pCube, Lit, k )
|
|
Count += Lit != PLA_LIT_DASH;
|
|
return Count;
|
|
}
|
|
static inline int Pla_ManLitOutNum( Pla_Man_t * p )
|
|
{
|
|
word * pCube; int i, k, Lit, Count = 0;
|
|
Pla_ForEachCubeOut( p, pCube, i )
|
|
Pla_CubeForEachLitOut( p, pCube, Lit, k )
|
|
Count += Lit == PLA_LIT_ONE;
|
|
return Count;
|
|
}
|
|
static inline void Pla_ManPrintStats( Pla_Man_t * p, int fVerbose )
|
|
{
|
|
printf( "%-16s : ", Pla_ManName(p) );
|
|
printf( "In =%4d ", Pla_ManInNum(p) );
|
|
printf( "Out =%4d ", Pla_ManOutNum(p) );
|
|
printf( "Cube =%8d ", Pla_ManCubeNum(p) );
|
|
printf( "LitIn =%8d ", Pla_ManLitInNum(p) );
|
|
printf( "LitOut =%8d ", Pla_ManLitOutNum(p) );
|
|
printf( "Div =%6d ", Pla_ManDivNum(p) );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
|
|
/*=== plaHash.c ========================================================*/
|
|
extern int Pla_ManHashDist1NumTest( Pla_Man_t * p );
|
|
extern void Pla_ManComputeDist1Test( Pla_Man_t * p );
|
|
/*=== plaMan.c ========================================================*/
|
|
extern Vec_Bit_t * Pla_ManPrimesTable( int nVars );
|
|
extern Pla_Man_t * Pla_ManPrimesDetector( int nVars );
|
|
extern Pla_Man_t * Pla_ManGenerate( int nIns, int nOuts, int nCubes, int fVerbose );
|
|
extern void Pla_ManConvertFromBits( Pla_Man_t * p );
|
|
extern void Pla_ManConvertToBits( Pla_Man_t * p );
|
|
extern int Pla_ManDist1NumTest( Pla_Man_t * p );
|
|
/*=== plaMerge.c ========================================================*/
|
|
extern int Pla_ManDist1Merge( Pla_Man_t * p );
|
|
/*=== plaSimple.c ========================================================*/
|
|
extern int Pla_ManFxPerformSimple( int nVars );
|
|
/*=== plaRead.c ========================================================*/
|
|
extern Pla_Man_t * Pla_ReadPla( char * pFileName );
|
|
/*=== plaWrite.c ========================================================*/
|
|
extern void Pla_WritePla( Pla_Man_t * p, char * pFileName );
|
|
|
|
ABC_NAMESPACE_HEADER_END
|
|
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// END OF FILE ///
|
|
////////////////////////////////////////////////////////////////////////
|