/**CFile****************************************************************
FileName [amapUniq.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Technology mapper for standard cells.]
Synopsis [Checks if the structural node already exists.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - June 20, 2005.]
Revision [$Id: amapUniq.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
***********************************************************************/
#include "amapInt.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Checks if the entry exists and returns value.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Vec_IntCheckWithMask( Vec_Int_t * p, int Entry )
{
int i;
for ( i = 0; i < p->nSize; i++ )
if ( (0xffff & p->pArray[i]) == (0xffff & Entry) )
return p->pArray[i] >> 16;
return -1;
}
/**Function*************************************************************
Synopsis [Pushes entry in the natural order.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Vec_IntPushOrderWithMask( Vec_Int_t * p, int Entry )
{
int i;
if ( p->nSize == p->nCap )
Vec_IntGrow( p, 2 * p->nCap );
p->nSize++;
for ( i = p->nSize-2; i >= 0; i-- )
if ( (0xffff & p->pArray[i]) > (0xffff & Entry) )
p->pArray[i+1] = p->pArray[i];
else
break;
p->pArray[i+1] = Entry;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Amap_LibFindNode( Amap_Lib_t * pLib, int iFan0, int iFan1, int fXor )
{
if ( fXor )
return Vec_IntCheckWithMask( (Vec_Int_t *)Vec_PtrEntry(pLib->vRulesX, iFan0), iFan1 );
else
return Vec_IntCheckWithMask( (Vec_Int_t *)Vec_PtrEntry(pLib->vRules, iFan0), iFan1 );
}
/**Function*************************************************************
Synopsis [Checks if the three-argument rule exist.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Amap_LibFindMux( Amap_Lib_t * p, int iFan0, int iFan1, int iFan2 )
{
int x;
for ( x = 0; x < Vec_IntSize(p->vRules3); x += 4 )
{
if ( Vec_IntEntry(p->vRules3, x) == iFan0 &&
Vec_IntEntry(p->vRules3, x+1) == iFan1 &&
Vec_IntEntry(p->vRules3, x+2) == iFan2 )
{
return Vec_IntEntry(p->vRules3, x+3);
}
}
return -1;
}
/**Function*************************************************************
Synopsis [Creates a new node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Amap_Nod_t * Amap_LibCreateObj( Amap_Lib_t * p )
{
Amap_Nod_t * pNode;
if ( p->nNodes == p->nNodesAlloc )
{
p->pNodes = ABC_REALLOC( Amap_Nod_t, p->pNodes, 2*p->nNodesAlloc );
p->nNodesAlloc *= 2;
}
pNode = Amap_LibNod( p, p->nNodes );
memset( pNode, 0, sizeof(Amap_Nod_t) );
pNode->Id = p->nNodes++;
Vec_PtrPush( p->vRules, Vec_IntAlloc(8) );
Vec_PtrPush( p->vRules, Vec_IntAlloc(8) );
Vec_PtrPush( p->vRulesX, Vec_IntAlloc(8) );
Vec_PtrPush( p->vRulesX, Vec_IntAlloc(8) );
return pNode;
}
/**Function*************************************************************
Synopsis [Creates a new node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Amap_LibCreateVar( Amap_Lib_t * p )
{
Amap_Nod_t * pNode;
// start the manager
assert( p->pNodes == NULL );
p->nNodesAlloc = 256;
p->pNodes = ABC_ALLOC( Amap_Nod_t, p->nNodesAlloc );
// create the first node
pNode = Amap_LibCreateObj( p );
p->pNodes->Type = AMAP_OBJ_PI;
p->pNodes->nSuppSize = 1;
return 0;
}
/**Function*************************************************************
Synopsis [Creates a new node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Amap_LibCreateNode( Amap_Lib_t * p, int iFan0, int iFan1, int fXor )
{
Amap_Nod_t * pNode;
int iFan;
if ( iFan0 < iFan1 )
{
iFan = iFan0;
iFan0 = iFan1;
iFan1 = iFan;
}
pNode = Amap_LibCreateObj( p );
pNode->Type = fXor? AMAP_OBJ_XOR : AMAP_OBJ_AND;
pNode->nSuppSize = p->pNodes[Abc_Lit2Var(iFan0)].nSuppSize + p->pNodes[Abc_Lit2Var(iFan1)].nSuppSize;
pNode->iFan0 = iFan0;
pNode->iFan1 = iFan1;
if ( p->fVerbose )
printf( "Creating node %5d %c : iFan0 = %5d%c iFan1 = %5d%c\n",
pNode->Id, (fXor?'x':' '),
Abc_Lit2Var(iFan0), (Abc_LitIsCompl(iFan0)?'-':'+'),
Abc_Lit2Var(iFan1), (Abc_LitIsCompl(iFan1)?'-':'+') );
if ( fXor )
{
if ( iFan0 == iFan1 )
Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRulesX, iFan0), (pNode->Id << 16) | iFan1 );
else
{
Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRulesX, iFan0), (pNode->Id << 16) | iFan1 );
Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRulesX, iFan1), (pNode->Id << 16) | iFan0 );
}
}
else
{
if ( iFan0 == iFan1 )
Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRules, iFan0), (pNode->Id << 16) | iFan1 );
else
{
Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRules, iFan0), (pNode->Id << 16) | iFan1 );
Vec_IntPushOrderWithMask( (Vec_Int_t *)Vec_PtrEntry(p->vRules, iFan1), (pNode->Id << 16) | iFan0 );
}
}
return pNode->Id;
}
/**Function*************************************************************
Synopsis [Creates a new node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Amap_LibCreateMux( Amap_Lib_t * p, int iFan0, int iFan1, int iFan2 )
{
Amap_Nod_t * pNode;
pNode = Amap_LibCreateObj( p );
pNode->Type = AMAP_OBJ_MUX;
pNode->nSuppSize = p->pNodes[Abc_Lit2Var(iFan0)].nSuppSize + p->pNodes[Abc_Lit2Var(iFan1)].nSuppSize + p->pNodes[Abc_Lit2Var(iFan2)].nSuppSize;
pNode->iFan0 = iFan0;
pNode->iFan1 = iFan1;
pNode->iFan2 = iFan2;
if ( p->fVerbose )
printf( "Creating node %5d %c : iFan0 = %5d%c iFan1 = %5d%c iFan2 = %5d%c\n",
pNode->Id, 'm',
Abc_Lit2Var(iFan0), (Abc_LitIsCompl(iFan0)?'-':'+'),
Abc_Lit2Var(iFan1), (Abc_LitIsCompl(iFan1)?'-':'+'),
Abc_Lit2Var(iFan2), (Abc_LitIsCompl(iFan2)?'-':'+') );
Vec_IntPush( p->vRules3, iFan0 );
Vec_IntPush( p->vRules3, iFan1 );
Vec_IntPush( p->vRules3, iFan2 );
Vec_IntPush( p->vRules3, pNode->Id );
return pNode->Id;
}
/**Function*************************************************************
Synopsis [Allocates triangular lookup table.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int ** Amap_LibLookupTableAlloc( Vec_Ptr_t * vVec, int fVerbose )
{
Vec_Int_t * vOne;
int ** pRes, * pBuffer;
int i, k, nTotal, nSize, nEntries, Value;
// count the total size
nEntries = nSize = Vec_PtrSize( vVec );
Vec_PtrForEachEntry( Vec_Int_t *, vVec, vOne, i )
nEntries += Vec_IntSize(vOne);
pBuffer = ABC_ALLOC( int, nSize * sizeof(void *) + nEntries );
pRes = (int **)pBuffer;
pRes[0] = pBuffer + nSize * sizeof(void *);
nTotal = 0;
Vec_PtrForEachEntry( Vec_Int_t *, vVec, vOne, i )
{
pRes[i] = pRes[0] + nTotal;
nTotal += Vec_IntSize(vOne) + 1;
if ( fVerbose )
printf( "%d : ", i );
Vec_IntForEachEntry( vOne, Value, k )
{
pRes[i][k] = Value;
if ( fVerbose )
printf( "%d(%d) ", Value&0xffff, Value>>16 );
}
if ( fVerbose )
printf( "\n" );
pRes[i][k] = 0;
}
assert( nTotal == nEntries );
return pRes;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END