#include "hop.h"

Functions
static ABC_NAMESPACE_IMPL_START int	Hop_ManTruthWordNum (int nVars)
	DECLARATIONS ///. More...

static void	Hop_ManTruthCopy (unsigned pOut, unsigned pIn, int nVars)

static void	Hop_ManTruthClear (unsigned *pOut, int nVars)

static void	Hop_ManTruthFill (unsigned *pOut, int nVars)

static void	Hop_ManTruthNot (unsigned pOut, unsigned pIn, int nVars)

int	Hop_ManConvertAigToTruth_rec1 (Hop_Obj_t *pObj)
	FUNCTION DEFINITIONS ///. More...

unsigned *	Hop_ManConvertAigToTruth_rec2 (Hop_Obj_t pObj, Vec_Int_t vTruth, int nWords)

unsigned *	Hop_ManConvertAigToTruth (Hop_Man_t p, Hop_Obj_t pRoot, int nVars, Vec_Int_t *vTruth, int fMsbFirst)

word	Hop_ManComputeTruth6_rec (Hop_Man_t p, Hop_Obj_t pObj)

word	Hop_ManComputeTruth6 (Hop_Man_t p, Hop_Obj_t pObj, int nVars)

Variables
static word	Truth [8]

Function Documentation

word Hop_ManComputeTruth6	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj,
		int	nVars
	)

Definition at line 256 of file hopTruth.c.

 {
     word Truth;
     int i;
     if ( Hop_ObjIsConst1( Hop_Regular(pObj) ) )
         return Hop_IsComplement(pObj) ? 0 : ~(word)0;
     for ( i = 0; i < nVars; i++ )
         Hop_ManPi( p, i )->iData = i;
     Truth = Hop_ManComputeTruth6_rec( p, Hop_Regular(pObj) );
     return Hop_IsComplement(pObj) ? ~Truth : Truth;
 }

word Hop_ManComputeTruth6_rec	(	Hop_Man_t *	p,
		Hop_Obj_t *	pObj
	)

Definition at line 244 of file hopTruth.c.

 {
     word Truth0, Truth1;
     if ( Hop_ObjIsPi(pObj) )
         return Truth[pObj->iData];
     assert( Hop_ObjIsNode(pObj) );
     Truth0 = Hop_ManComputeTruth6_rec( p, Hop_ObjFanin0(pObj) );
     Truth1 = Hop_ManComputeTruth6_rec( p, Hop_ObjFanin1(pObj) );
     Truth0 = Hop_ObjFaninC0(pObj) ? ~Truth0 : Truth0;
     Truth1 = Hop_ObjFaninC1(pObj) ? ~Truth1 : Truth1;
     return Truth0 & Truth1;
 }

unsigned* Hop_ManConvertAigToTruth	(	Hop_Man_t *	p,
		Hop_Obj_t *	pRoot,
		int	nVars,
		Vec_Int_t *	vTruth,
		int	fMsbFirst
	)

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

Synopsis [Computes truth table of the node.]

Description [Assumes that the structural support is no more than 8 inputs. Uses array vTruth to store temporary truth tables. The returned pointer should be used immediately.]

SideEffects []

SeeAlso []

Definition at line 143 of file hopTruth.c.

 {
     static unsigned uTruths[8][8] = { // elementary truth tables
         { 0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA },
         { 0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC },
         { 0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0 },
         { 0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00 },
         { 0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000 }, 
         { 0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF }, 
         { 0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF }, 
         { 0x00000000,0x00000000,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF } 
     };
     Hop_Obj_t * pObj;
     unsigned * pTruth, * pTruth2;
     int i, nWords, nNodes;
     Vec_Ptr_t * vTtElems;
 
     // if the number of variables is more than 8, allocate truth tables
     if ( nVars > 8 )
         vTtElems = Vec_PtrAllocTruthTables( nVars );
     else
         vTtElems = NULL;
 
     // clear the data fields and set marks
     nNodes = Hop_ManConvertAigToTruth_rec1( Hop_Regular(pRoot) );
     // prepare memory
     nWords = Hop_TruthWordNum( nVars );
     Vec_IntClear( vTruth );
     Vec_IntGrow( vTruth, nWords * (nNodes+1) );
     pTruth = Vec_IntFetch( vTruth, nWords );
     // check the case of a constant
     if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
     {
         assert( nNodes == 0 );
         if ( Hop_IsComplement(pRoot) )
             Hop_ManTruthClear( pTruth, nVars );
         else
             Hop_ManTruthFill( pTruth, nVars );
         return pTruth;
     }
     // set elementary truth tables at the leaves
     assert( nVars <= Hop_ManPiNum(p) );
 //    assert( Hop_ManPiNum(p) <= 8 ); 
     if ( fMsbFirst )
     {
 //        Hop_ManForEachPi( p, pObj, i )
         for ( i = 0; i < nVars; i++ )
         {
             pObj = Hop_ManPi( p, i );
             if ( vTtElems )
                 pObj->pData = Vec_PtrEntry(vTtElems, nVars-1-i);
             else               
                 pObj->pData = (void *)uTruths[nVars-1-i];
         }
     }
     else
     {
 //        Hop_ManForEachPi( p, pObj, i )
         for ( i = 0; i < nVars; i++ )
         {
             pObj = Hop_ManPi( p, i );
             if ( vTtElems )
                 pObj->pData = Vec_PtrEntry(vTtElems, i);
             else               
                 pObj->pData = (void *)uTruths[i];
         }
     }
     // clear the marks and compute the truth table
     pTruth2 = Hop_ManConvertAigToTruth_rec2( Hop_Regular(pRoot), vTruth, nWords );
     // copy the result
     Hop_ManTruthCopy( pTruth, pTruth2, nVars );
     if ( Hop_IsComplement(pRoot) )
         Hop_ManTruthNot( pTruth, pTruth, nVars );
     if ( vTtElems )
         Vec_PtrFree( vTtElems );
     return pTruth;
 }

int Hop_ManConvertAigToTruth_rec1 ( Hop_Obj_t * pObj )

FUNCTION DEFINITIONS ///.

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

Synopsis [Construct BDDs and mark AIG nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 73 of file hopTruth.c.

 {
     int Counter = 0;
     assert( !Hop_IsComplement(pObj) );
     if ( !Hop_ObjIsNode(pObj) || Hop_ObjIsMarkA(pObj) )
         return 0;
     Counter += Hop_ManConvertAigToTruth_rec1( Hop_ObjFanin0(pObj) ); 
     Counter += Hop_ManConvertAigToTruth_rec1( Hop_ObjFanin1(pObj) );
     assert( !Hop_ObjIsMarkA(pObj) ); // loop detection
     Hop_ObjSetMarkA( pObj );
     return Counter + 1;
 }

unsigned* Hop_ManConvertAigToTruth_rec2	(	Hop_Obj_t *	pObj,
		Vec_Int_t *	vTruth,
		int	nWords
	)

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

Synopsis [Computes truth table of the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 97 of file hopTruth.c.

 {
     unsigned * pTruth, * pTruth0, * pTruth1;
     int i;
     assert( !Hop_IsComplement(pObj) );
     if ( !Hop_ObjIsNode(pObj) || !Hop_ObjIsMarkA(pObj) )
         return (unsigned *)pObj->pData;
     // compute the truth tables of the fanins
     pTruth0 = Hop_ManConvertAigToTruth_rec2( Hop_ObjFanin0(pObj), vTruth, nWords );
     pTruth1 = Hop_ManConvertAigToTruth_rec2( Hop_ObjFanin1(pObj), vTruth, nWords );
     // creat the truth table of the node
     pTruth  = Vec_IntFetch( vTruth, nWords );
     if ( Hop_ObjIsExor(pObj) )
         for ( i = 0; i < nWords; i++ )
             pTruth[i] = pTruth0[i] ^ pTruth1[i];
     else if ( !Hop_ObjFaninC0(pObj) && !Hop_ObjFaninC1(pObj) )
         for ( i = 0; i < nWords; i++ )
             pTruth[i] = pTruth0[i] & pTruth1[i];
     else if ( !Hop_ObjFaninC0(pObj) && Hop_ObjFaninC1(pObj) )
         for ( i = 0; i < nWords; i++ )
             pTruth[i] = pTruth0[i] & ~pTruth1[i];
     else if ( Hop_ObjFaninC0(pObj) && !Hop_ObjFaninC1(pObj) )
         for ( i = 0; i < nWords; i++ )
             pTruth[i] = ~pTruth0[i] & pTruth1[i];
     else // if ( Hop_ObjFaninC0(pObj) && Hop_ObjFaninC1(pObj) )
         for ( i = 0; i < nWords; i++ )
             pTruth[i] = ~pTruth0[i] & ~pTruth1[i];
     assert( Hop_ObjIsMarkA(pObj) ); // loop detection
     Hop_ObjClearMarkA( pObj );
     pObj->pData = pTruth;
     return pTruth;
 }

static void Hop_ManTruthClear	(	unsigned *	pOut,
		int	nVars
	)

inlinestatic

Definition at line 38 of file hopTruth.c.

 {
     int w;
     for ( w = Hop_ManTruthWordNum(nVars)-1; w >= 0; w-- )
         pOut[w] = 0;
 }

static void Hop_ManTruthCopy	(	unsigned *	pOut,
		unsigned *	pIn,
		int	nVars
	)

inlinestatic

Definition at line 32 of file hopTruth.c.

 {
     int w;
     for ( w = Hop_ManTruthWordNum(nVars)-1; w >= 0; w-- )
         pOut[w] = pIn[w];
 }

static void Hop_ManTruthFill	(	unsigned *	pOut,
		int	nVars
	)

inlinestatic

Definition at line 44 of file hopTruth.c.

 {
     int w;
     for ( w = Hop_ManTruthWordNum(nVars)-1; w >= 0; w-- )
         pOut[w] = ~(unsigned)0;
 }

static void Hop_ManTruthNot	(	unsigned *	pOut,
		unsigned *	pIn,
		int	nVars
	)

inlinestatic

Definition at line 50 of file hopTruth.c.

 {
     int w;
     for ( w = Hop_ManTruthWordNum(nVars)-1; w >= 0; w-- )
         pOut[w] = ~pIn[w];
 }

static ABC_NAMESPACE_IMPL_START int Hop_ManTruthWordNum ( int nVars )

inlinestatic

DECLARATIONS ///.

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

FileName [hopTruth.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Minimalistic And-Inverter Graph package.]

Synopsis []

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 11, 2006.]

Revision [

Id:: hopTruth.c,v 1.00 2006/05/11 00:00:00 alanmi Exp

]

Definition at line 30 of file hopTruth.c.

30 { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }

Variable Documentation

word Truth[8]

static

Initial value:

= 
{
    ABC_CONST(0xAAAAAAAAAAAAAAAA),
    ABC_CONST(0xCCCCCCCCCCCCCCCC),
    ABC_CONST(0xF0F0F0F0F0F0F0F0),
    ABC_CONST(0xFF00FF00FF00FF00),
    ABC_CONST(0xFFFF0000FFFF0000),
    ABC_CONST(0xFFFFFFFF00000000),
    ABC_CONST(0x0000000000000000),
}

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

Synopsis [Compute truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 233 of file hopTruth.c.

Functions

Variables

Function Documentation

Variable Documentation