#include "base/abc/abc.h"

Data Structures
struct	Abc_ShaMan_t_

Macros
#define	SHARE_NUM 2
	DECLARATIONS ///. More...

Typedefs
typedef struct Abc_ShaMan_t_	Abc_ShaMan_t

Functions
static word	Abc_NtkSharePack (int Lev, int Id)

static int	Abc_NtkShareUnpackLev (word Num)

static int	Abc_NtkShareUnpackId (word Num)

Abc_ShaMan_t *	Abc_ShaManStart (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///. More...

void	Abc_ShaManStop (Abc_ShaMan_t *p)

Vec_Wrd_t *	Abc_NtkShareSuperXor (Abc_Obj_t pObj, int pfCompl, int *pCounter)

Vec_Wrd_t *	Abc_NtkShareSuperAnd (Abc_Obj_t pObj, int pCounter)

void	Abc_NtkTraverseSupersXor_rec (Abc_ShaMan_t p, Abc_Obj_t pObj, Vec_Ptr_t *vInputs)

void	Abc_NtkTraverseSupersAnd_rec (Abc_ShaMan_t p, Abc_Obj_t pObj, Vec_Ptr_t *vInputs)

void	Abc_NtkTraverseSupers (Abc_ShaMan_t *p, int fAnd)

void	Abc_NtkSharePrint (Abc_ShaMan_t *p)

void	Abc_NtkDumpBlif (Abc_Ntk_t *p)

void	Abc_NtkShareFindBestMatch (Vec_Ptr_t vBuckets, Vec_Int_t pvInput, Vec_Int_t *pvInput2)

void	Abc_NtkShareOptimize (Abc_ShaMan_t *p, int fAnd)

Abc_Ntk_t *	Abc_NtkUpdateNetwork (Abc_ShaMan_t *p, int fAnd)

Abc_Ntk_t *	Abc_NtkShareXor (Abc_Ntk_t *pNtk, int nMultiSize, int fAnd, int fVerbose)

Macro Definition Documentation

#define SHARE_NUM 2

DECLARATIONS ///.

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

FileName [abcShare.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Shared logic extraction.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:: abcShare.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 29 of file abcExtract.c.

Typedef Documentation

typedef struct Abc_ShaMan_t_ Abc_ShaMan_t

Definition at line 31 of file abcExtract.c.

Function Documentation

void Abc_NtkDumpBlif ( Abc_Ntk_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 422 of file abcExtract.c.

 {
     FILE * pFile;
     Vec_Ptr_t * vSupp;
     Abc_Obj_t * pObj;
     int i, k;
     pFile = fopen( "multi_and.blif", "wb" );
     if ( pFile == NULL )
     {
         printf( "Cannot open output file.\n" );
         return;
     }
     fprintf( pFile, ".model %s\n", "multi_and" );
     fprintf( pFile, ".inputs" );
     for ( i = 0; i < Abc_NtkCiNum(p); i++ )
         fprintf( pFile, " i%d", i );
     fprintf( pFile, "\n" );
     fprintf( pFile, ".outputs" );
     for ( i = 0; i < Abc_NtkCoNum(p); i++ )
         fprintf( pFile, " o%d", i );
     fprintf( pFile, "\n" );
     Abc_NtkForEachCi( p, pObj, i )
         pObj->iTemp = i;
     for ( i = 0; i < Abc_NtkCoNum(p); i++ )
     {
         pObj = Abc_NtkCo( p, i );
         vSupp = Abc_NtkNodeSupport( p, &pObj, 1 );
         fprintf( pFile, ".names" );
         Vec_PtrForEachEntry( Abc_Obj_t *, vSupp, pObj, k )
             fprintf( pFile, " i%d", pObj->iTemp );
         fprintf( pFile, " o%d\n", i );
         Vec_PtrForEachEntry( Abc_Obj_t *, vSupp, pObj, k )
             fprintf( pFile, "1" );
         fprintf( pFile, " 1\n" );
         Vec_PtrFree( vSupp );
     }
     fprintf( pFile, ".end\n\n" );
     fclose( pFile );
 }

void Abc_NtkShareFindBestMatch	(	Vec_Ptr_t *	vBuckets,
		Vec_Int_t **	pvInput,
		Vec_Int_t **	pvInput2
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 474 of file abcExtract.c.

 {
     int nPoolSize = 40;
     Vec_Ptr_t * vPool = Vec_PtrAlloc( nPoolSize );
     Vec_Ptr_t * vBucket;
     Vec_Int_t * vInput, * vInput2, * vInputBest = NULL, * vInputBest2 = NULL;
     int i, k, Cost, CostBest = 0, Delay, DelayBest = 0;
 
     Vec_PtrForEachEntryReverse( Vec_Ptr_t *, vBuckets, vBucket, i )
         Vec_PtrForEachEntry( Vec_Int_t *, vBucket, vInput, k )
         {
             Vec_PtrPush( vPool, vInput );
             if ( Vec_PtrSize(vPool) == nPoolSize )
                 goto outside;
         }
 outside:
 
     Vec_PtrForEachEntryReverse( Vec_Int_t *, vPool, vInput, i )
     Vec_PtrForEachEntryReverse( Vec_Int_t *, vPool, vInput2, k )
     {
         if ( i == k )
             continue;
 
         vInput->pArray += SHARE_NUM;
         vInput2->pArray += SHARE_NUM;
         vInput->nSize -= SHARE_NUM;
         vInput2->nSize -= SHARE_NUM;
 
         Cost = Vec_IntTwoCountCommon(vInput, vInput2);
 
         vInput->pArray -= SHARE_NUM;
         vInput2->pArray -= SHARE_NUM;
         vInput->nSize += SHARE_NUM;
         vInput2->nSize += SHARE_NUM;
 
         if ( Cost < 2 )
             continue;
 
         Delay = Abc_MaxInt( Vec_IntEntry(vInput, 1), Vec_IntEntry(vInput2, 1) );
 
         if ( CostBest < Cost || (CostBest == Cost && (DelayBest > Delay)) )
         {
             CostBest = Cost;
             DelayBest = Delay;
             vInputBest = vInput;
             vInputBest2 = vInput2;
         }
     }
     Vec_PtrFree( vPool );
 
     *pvInput  = vInputBest;
     *pvInput2 = vInputBest2;
 
     if ( vInputBest == NULL )
         return;
 
     Vec_PtrRemove( (Vec_Ptr_t *)Vec_PtrEntry(vBuckets, Vec_IntSize(vInputBest)-SHARE_NUM),  (Vec_Int_t *)vInputBest ); 
     Vec_PtrRemove( (Vec_Ptr_t *)Vec_PtrEntry(vBuckets, Vec_IntSize(vInputBest2)-SHARE_NUM), (Vec_Int_t *)vInputBest2 ); 
 }

void Abc_NtkShareOptimize	(	Abc_ShaMan_t *	p,
		int	fAnd
	)

Definition at line 533 of file abcExtract.c.

 {
     Abc_Obj_t * pObj, * pObj0, * pObj1;
     Vec_Int_t * vInput, * vInput2;
     Vec_Int_t * vNew, * vOld1, * vOld2;
     int i;
     for ( i = 0; ; i++ )
     {
         Abc_NtkShareFindBestMatch( p->vBuckets, &vInput, &vInput2 );
         if ( vInput == NULL )
             break;
 
         // create new node
         pObj0 = Abc_ObjFromLit( p->pNtk, Vec_IntEntry(vInput,  0) );
         pObj1 = Abc_ObjFromLit( p->pNtk, Vec_IntEntry(vInput2, 0) );
         if ( fAnd )
             pObj  = Abc_AigAnd( (Abc_Aig_t *)p->pNtk->pManFunc, pObj0, pObj1 );
         else
             pObj  = Abc_AigXor( (Abc_Aig_t *)p->pNtk->pManFunc, pObj0, pObj1 );
         p->nCountGates++;
 
         // save new node
         vOld1 = Vec_IntAlloc( 16 );  Vec_IntPush( vOld1, Vec_IntEntry(vInput,  0) );  Vec_IntPush( vOld1, Vec_IntEntry(vInput,  1) );
         vOld2 = Vec_IntAlloc( 16 );  Vec_IntPush( vOld2, Vec_IntEntry(vInput2, 0) );  Vec_IntPush( vOld2, Vec_IntEntry(vInput2, 1) );
         vNew  = Vec_IntAlloc( 16 );  Vec_IntPush( vNew,  Abc_ObjToLit(pObj) );        Vec_IntPush( vNew, Abc_ObjLevel(Abc_ObjRegular(pObj)) );
 
         // compute new arrays
         vInput->pArray += SHARE_NUM;
         vInput2->pArray += SHARE_NUM;
         vInput->nSize -= SHARE_NUM;
         vInput2->nSize -= SHARE_NUM;
 
         Vec_IntTwoSplit( vInput, vInput2, vNew, vOld1, vOld2 );
 
         vInput->pArray -= SHARE_NUM;
         vInput2->pArray -= SHARE_NUM;
         vInput->nSize += SHARE_NUM;
         vInput2->nSize += SHARE_NUM;
 
         // add to the old ones
         Vec_IntPush( vOld1, Vec_IntSize(p->vObj2Lit) );
         Vec_IntPush( vOld2, Vec_IntSize(p->vObj2Lit) );
         Vec_IntPush( p->vObj2Lit, Abc_ObjToLit(pObj) );
 
         Vec_PtrPush( (Vec_Ptr_t *)Vec_PtrEntry(p->vBuckets, Vec_IntSize(vOld1)-SHARE_NUM), vOld1 );
         Vec_PtrPush( (Vec_Ptr_t *)Vec_PtrEntry(p->vBuckets, Vec_IntSize(vOld2)-SHARE_NUM), vOld2 );
         Vec_PtrPush( (Vec_Ptr_t *)Vec_PtrEntry(p->vBuckets, Vec_IntSize(vNew)-SHARE_NUM), vNew );
 
         Vec_IntFree( vInput );
         Vec_IntFree( vInput2 );
     }
 }

static word Abc_NtkSharePack	(	int	Lev,
		int	Id
	)

inlinestatic

Definition at line 44 of file abcExtract.c.

44 { return (((word)Lev) << 32) | Id; }

word

unsigned __int64 word

DECLARATIONS ///.

Definition: kitPerm.c:36

void Abc_NtkSharePrint ( Abc_ShaMan_t * p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 367 of file abcExtract.c.

 {
     Vec_Ptr_t * vBucket;
     Vec_Int_t * vInput;
     int i, k, j, ObjId;
     char * pBuffer = ABC_ALLOC( char, Vec_IntSize(p->vObj2Lit) + 1 );
     int * pCounters = ABC_CALLOC( int, Vec_IntSize(p->vObj2Lit) + 1 );
     int nTotal = 0;
     Vec_PtrForEachEntry( Vec_Ptr_t *, p->vBuckets, vBucket, i )
     Vec_PtrForEachEntry( Vec_Int_t *, vBucket, vInput, j )
     {
         for ( k = 0; k < Vec_IntSize(p->vObj2Lit); k++ )
             pBuffer[k] = '0';
         pBuffer[k] = 0;
 
         Vec_IntForEachEntryStart( vInput, ObjId, k, SHARE_NUM )
         {
             assert( ObjId < Vec_IntSize(p->vObj2Lit) );
             pBuffer[ObjId] = '1';
             pCounters[ObjId]++;
         }
         printf( "%4d%3d: %s\n", Vec_IntEntry(vInput, 0), Vec_IntEntry(vInput, 1), pBuffer );
     }
 
     for ( i = 0; i < Vec_IntSize(p->vObj2Lit); i++ )
         if ( pCounters[i] > 0 )
             printf( "%d=%d ", i, pCounters[i] ); 
     printf( "\n" );
 
     nTotal = 0;
     for ( i = 0; i < p->nStartCols; i++ )
         nTotal += pCounters[i] - 1;
     printf( "Total = %d.  ", nTotal );
     printf( "Gates = %d.\n", Vec_IntSize(p->vObj2Lit) - p->nStartCols + nTotal );
 
     ABC_FREE( pCounters );
     ABC_FREE( pBuffer );
 
     printf( "Bucket contents: " );
     Vec_PtrForEachEntry( Vec_Ptr_t *, p->vBuckets, vBucket, i )
         printf( "%d ", Vec_PtrSize(vBucket) );
     printf( "\n" );
 }

Vec_Wrd_t* Abc_NtkShareSuperAnd	(	Abc_Obj_t *	pObj,
		int *	pCounter
	)

Definition at line 159 of file abcExtract.c.

 {
     Abc_Ntk_t * pNtk = Abc_ObjNtk(pObj);
     Abc_Obj_t * pObj0, * pObj1, * pRoot = NULL;
     Vec_Wrd_t * vSuper;
     word Num, NumNext;
     int i, k;
     assert( !Abc_ObjIsComplement(pObj) );
     // start iteration
     vSuper = Vec_WrdAlloc( 10 );
     Vec_WrdPush( vSuper, Abc_NtkSharePack(Abc_ObjLevel(pObj), Abc_ObjToLit(pObj)) );
     while ( Vec_WrdSize(vSuper) > 0 )
     {
         // make sure there are no duplicates
         Num = Vec_WrdEntry( vSuper, 0 );
         Vec_WrdForEachEntryStart( vSuper, NumNext, i, 1 )
         {
             assert( Num < NumNext );
             Num = NumNext;
         }
         // extract AND gate decomposable on the topmost level
         Vec_WrdForEachEntryReverse( vSuper, Num, i )
         {
             pRoot = Abc_ObjFromLit( pNtk, Abc_NtkShareUnpackId(Num) );
             if ( !Abc_ObjIsComplement(pRoot) && Abc_ObjIsNode(pRoot) )
             {
                 Vec_WrdRemove( vSuper, Num );
                 break;
             }
         }
         if ( i == -1 )
             break;
         assert( Abc_ObjIsNode(pRoot) );
         // extract
         pObj0 = Abc_ObjChild0(pRoot);
         pObj1 = Abc_ObjChild1(pRoot);
         assert( Abc_ObjIsNode(Abc_ObjRegular(pObj0)) || Abc_ObjIsCi(Abc_ObjRegular(pObj0)) );
         assert( Abc_ObjIsNode(Abc_ObjRegular(pObj1)) || Abc_ObjIsCi(Abc_ObjRegular(pObj1)) );
         Vec_WrdPushOrder( vSuper, Abc_NtkSharePack(Abc_ObjLevel(Abc_ObjRegular(pObj0)), Abc_ObjToLit(pObj0)) );
         Vec_WrdPushOrder( vSuper, Abc_NtkSharePack(Abc_ObjLevel(Abc_ObjRegular(pObj1)), Abc_ObjToLit(pObj1)) );
         (*pCounter)++;
         // remove duplicates
         k = 0;
         Vec_WrdForEachEntry( vSuper, Num, i )
         {
             if ( i + 1 == Vec_WrdSize(vSuper) )
             {
                 Vec_WrdWriteEntry( vSuper, k++, Num );
                 break;
             }
             NumNext = Vec_WrdEntry( vSuper, i+1 );
             assert( Num <= NumNext );
             if ( Num + 1 == NumNext && (NumNext & 1) ) // pos_lit & neg_lit = 0
             {
                 Vec_WrdClear( vSuper );
                 return vSuper;
             }
             if ( Num < NumNext )
                 Vec_WrdWriteEntry( vSuper, k++, Num );
         }
         Vec_WrdShrink( vSuper, k );
     }
     Vec_WrdForEachEntry( vSuper, Num, i )
         Vec_WrdWriteEntry( vSuper, i, Abc_NtkShareUnpackId(Num) );
     return vSuper;
 }

Vec_Wrd_t* Abc_NtkShareSuperXor	(	Abc_Obj_t *	pObj,
		int *	pfCompl,
		int *	pCounter
	)

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

Synopsis [Collects one multi-input gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 95 of file abcExtract.c.

 {
     Abc_Ntk_t * pNtk = Abc_ObjNtk(pObj);
     Abc_Obj_t * pObjC, * pObj0, * pObj1, * pRoot = NULL;
     Vec_Wrd_t * vSuper;
     word Num, NumNext;
     int i, k, fCompl = 0;
     assert( !Abc_ObjIsComplement(pObj) );
     assert( Abc_NodeIsExorType(pObj) );
     // start iteration
     vSuper = Vec_WrdAlloc( 10 );
     Vec_WrdPush( vSuper, Abc_NtkSharePack(Abc_ObjLevel(pObj), Abc_ObjId(pObj)) );
     while ( Vec_WrdSize(vSuper) > 0 )
     {
         // make sure there are no duplicates
         Num = Vec_WrdEntry( vSuper, 0 );
         Vec_WrdForEachEntryStart( vSuper, NumNext, i, 1 )
         {
             assert( Num < NumNext );
             Num = NumNext;
         }
         // extract XOR gate decomposable on the topmost level
         Vec_WrdForEachEntryReverse( vSuper, Num, i )
         {
             pRoot = Abc_NtkObj( pNtk, Abc_NtkShareUnpackId(Num) );
             if ( Abc_NodeIsExorType(pRoot) )
             {
                 Vec_WrdRemove( vSuper, Num );
                 break;
             }
         }
         if ( i == -1 )
             break;
         // extract
         pObjC = Abc_NodeRecognizeMux( pRoot, &pObj1, &pObj0 );
         assert( pObj1 == Abc_ObjNot(pObj0) );
         fCompl ^= Abc_ObjIsComplement(pObjC);  pObjC = Abc_ObjRegular(pObjC);
         fCompl ^= Abc_ObjIsComplement(pObj0);  pObj0 = Abc_ObjRegular(pObj0);
         Vec_WrdPushOrder( vSuper, Abc_NtkSharePack(Abc_ObjLevel(pObjC), Abc_ObjId(pObjC)) );
         Vec_WrdPushOrder( vSuper, Abc_NtkSharePack(Abc_ObjLevel(pObj0), Abc_ObjId(pObj0)) );
         (*pCounter)++;
         // remove duplicates
         k = 0;
         Vec_WrdForEachEntry( vSuper, Num, i )
         {
             if ( i + 1 == Vec_WrdSize(vSuper) )
             {
                 Vec_WrdWriteEntry( vSuper, k++, Num );
                 break;
             }
             NumNext = Vec_WrdEntry( vSuper, i+1 );
             assert( Num <= NumNext );
             if ( Num == NumNext )
                 i++;
             else
                 Vec_WrdWriteEntry( vSuper, k++, Num );
         }
         Vec_WrdShrink( vSuper, k );
     }
     *pfCompl = fCompl;
     Vec_WrdForEachEntry( vSuper, Num, i )
         Vec_WrdWriteEntry( vSuper, i, Abc_NtkShareUnpackId(Num) );
     return vSuper;
 }

static int Abc_NtkShareUnpackId ( word Num )

inlinestatic

Definition at line 46 of file abcExtract.c.

46 { return Num & 0xFFFFFFFF; }

static int Abc_NtkShareUnpackLev ( word Num )

inlinestatic

Definition at line 45 of file abcExtract.c.

45 { return (Num >> 32); }

Abc_Ntk_t* Abc_NtkShareXor	(	Abc_Ntk_t *	pNtk,
		int	nMultiSize,
		int	fAnd,
		int	fVerbose
	)

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

Synopsis [Extracts one multi-output XOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 720 of file abcExtract.c.

 {
     Abc_Ntk_t * pNtkNew;
     Abc_ShaMan_t * p;
     assert( Abc_NtkIsStrash(pNtk) );
 //    Abc_NtkDumpBlif( pNtk );
     p = Abc_ShaManStart( pNtk );
     p->nMultiSize = nMultiSize;
     p->fVerbose   = fVerbose;
     Abc_NtkTraverseSupers( p, fAnd );
     if ( p->nStartCols < 2 )
     {
         Abc_ShaManStop( p );
         return Abc_NtkDup( pNtk );
     }
     if ( fVerbose )
         Abc_NtkSharePrint( p );
     Abc_NtkShareOptimize( p, fAnd );
     if ( fVerbose )
         Abc_NtkSharePrint( p );
     pNtkNew = Abc_NtkUpdateNetwork( p, fAnd );
     Abc_ShaManStop( p );
     return pNtkNew;
 }

void Abc_NtkTraverseSupers	(	Abc_ShaMan_t *	p,
		int	fAnd
	)

Definition at line 313 of file abcExtract.c.

 {
     Vec_Ptr_t * vInputs;
     Vec_Int_t * vInput;
     Abc_Obj_t * pObj;
     int i, nOnesMax;
 
     // create mapping of nodes into their column vectors
     vInputs = Vec_PtrStart( Abc_NtkObjNumMax(p->pNtk) * (1 + fAnd) );
     Abc_NtkIncrementTravId( p->pNtk );
     if ( fAnd )
     {
         Abc_NtkForEachCo( p->pNtk, pObj, i )
             if ( Abc_ObjIsNode(Abc_ObjFanin0(pObj)) )
                 Abc_NtkTraverseSupersAnd_rec( p, Abc_ObjFanin0(pObj), vInputs );
     }
     else
     {
         Abc_NtkForEachCo( p->pNtk, pObj, i )
             if ( Abc_ObjIsNode(Abc_ObjFanin0(pObj)) )
                 Abc_NtkTraverseSupersXor_rec( p, Abc_ObjFanin0(pObj), vInputs );
     }
     p->nStartCols = Vec_IntSize(p->vObj2Lit);
 
     // find the largest number of 1s
     nOnesMax = 0;
     Vec_PtrForEachEntry( Vec_Int_t *, vInputs, vInput, i )
         if ( vInput )
             nOnesMax = Abc_MaxInt( nOnesMax, Vec_IntSize(vInput)-SHARE_NUM );
 
     // create buckets
     assert( p->vBuckets == NULL );
     p->vBuckets = Vec_PtrAlloc( nOnesMax + 1 );
     for ( i = 0; i <= nOnesMax; i++ )
         Vec_PtrPush( p->vBuckets, Vec_PtrAlloc(10) );
 
     // load vectors into buckets
     Vec_PtrForEachEntry( Vec_Int_t *, vInputs, vInput, i )
         if ( vInput )
             Vec_PtrPush( (Vec_Ptr_t *)Vec_PtrEntry(p->vBuckets, Vec_IntSize(vInput)-SHARE_NUM), vInput );
     Vec_PtrFree( vInputs );
 }

void Abc_NtkTraverseSupersAnd_rec	(	Abc_ShaMan_t *	p,
		Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vInputs
	)

Definition at line 279 of file abcExtract.c.

 {
     Vec_Wrd_t * vSuper;
     word Num;
     int k;
     if ( Abc_NodeIsTravIdCurrent( pObj ) )
         return;
     Abc_NodeSetTravIdCurrent( pObj );
     if ( Abc_ObjIsCi(pObj) )
         return;
     assert( Abc_ObjIsNode(pObj) );
     vSuper = Abc_NtkShareSuperAnd( pObj, &p->nFoundGates );
     if ( Vec_WrdSize(vSuper) <= 1 || Vec_WrdSize(vSuper) >= p->nMultiSize )
     {
         Vec_WrdForEachEntry( vSuper, Num, k )
         {
             Vec_Int_t * vInput = (Vec_Int_t *)Vec_PtrEntry( vInputs, (int)Num );
             if ( vInput == NULL )
             {
                 vInput = Vec_IntAlloc( 10 );
                 Vec_IntPush( vInput, (int)Num );
                 Vec_IntPush( vInput, Abc_ObjLevel(Abc_NtkObj(p->pNtk, Abc_Lit2Var((int)Num))) );
                 assert( SHARE_NUM == Vec_IntSize(vInput) );
                 Vec_PtrWriteEntry( vInputs, (int)Num, vInput );
             }
             Vec_IntPush( vInput, Vec_IntSize(p->vObj2Lit) );
         }
         Vec_IntPush( p->vObj2Lit, Abc_ObjToLit(pObj) );
     }
     // call recursively
     Vec_WrdForEachEntry( vSuper, Num, k )
         Abc_NtkTraverseSupersAnd_rec( p, Abc_NtkObj(p->pNtk, Abc_Lit2Var((int)Num)), vInputs );
     Vec_WrdFree( vSuper );
 }

void Abc_NtkTraverseSupersXor_rec	(	Abc_ShaMan_t *	p,
		Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vInputs
	)

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

Synopsis [Creates multi-input XOR representation for the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 237 of file abcExtract.c.

 {
     if ( Abc_NodeIsTravIdCurrent( pObj ) )
         return;
     Abc_NodeSetTravIdCurrent( pObj );
     if ( Abc_ObjIsCi(pObj) )
         return;
     assert( Abc_ObjIsNode(pObj) );
     if ( Abc_NodeIsExorType(pObj) )
     {
         Vec_Wrd_t * vSuper;
         int k, fCompl;
         word Num;
         vSuper = Abc_NtkShareSuperXor( pObj, &fCompl, &p->nFoundGates );
         if ( Vec_WrdSize(vSuper) <= 1 || Vec_WrdSize(vSuper) >= p->nMultiSize )
         {
             Vec_WrdForEachEntry( vSuper, Num, k )
             {
                 Vec_Int_t * vInput = (Vec_Int_t *)Vec_PtrEntry( vInputs, (int)Num );
                 if ( vInput == NULL )
                 {
                     vInput = Vec_IntAlloc( 10 );
                     Vec_IntPush( vInput, Abc_Var2Lit((int)Num, 0) );
                     Vec_IntPush( vInput, Abc_ObjLevel(Abc_NtkObj(p->pNtk, (int)Num)) );
                     assert( SHARE_NUM == Vec_IntSize(vInput) );
                     Vec_PtrWriteEntry( vInputs, (int)Num, vInput );
                 }
                 Vec_IntPush( vInput, Vec_IntSize(p->vObj2Lit) );
             }
             Vec_IntPush( p->vObj2Lit, Abc_Var2Lit(Abc_ObjId(pObj), fCompl) );
         }
         // call recursively
         Vec_WrdForEachEntry( vSuper, Num, k )
             Abc_NtkTraverseSupersXor_rec( p, Abc_NtkObj(p->pNtk, (int)Num), vInputs );
         Vec_WrdFree( vSuper );
     }
     else
     {
         Abc_NtkTraverseSupersXor_rec( p, Abc_ObjFanin0(pObj), vInputs );
         Abc_NtkTraverseSupersXor_rec( p, Abc_ObjFanin1(pObj), vInputs );
     }
 }

Abc_Ntk_t* Abc_NtkUpdateNetwork	(	Abc_ShaMan_t *	p,
		int	fAnd
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 597 of file abcExtract.c.

 {
     Abc_Ntk_t * pNtk;
     Vec_Int_t * vInput, * vMap2Repl;
     Vec_Ptr_t * vOrig, * vRepl, * vBucket;
     Abc_Obj_t * pObj, * pNew;
     int i, j, k, ObjId, iLit;
     int iLitConst1 = Abc_ObjToLit( Abc_AigConst1(p->pNtk) );
 
     vOrig = Vec_PtrAlloc( p->nStartCols );
     vRepl = Vec_PtrAlloc( p->nStartCols );
     for ( i = 0; i < p->nStartCols; i++ )
     {
         iLit = Vec_IntEntry( p->vObj2Lit, i );
         assert( !fAnd || !Abc_LitIsCompl(iLit) );
 
         pObj = Abc_NtkObj( p->pNtk, Abc_Lit2Var(iLit) );
 
         if ( fAnd )
             pNew = Abc_AigConst1(p->pNtk);
         else
             pNew = Abc_ObjNotCond( Abc_AigConst1(p->pNtk), !Abc_LitIsCompl(iLit) );
 
         Vec_PtrPush( vOrig, pObj );
         Vec_PtrPush( vRepl, pNew );
 
         p->nCountGates--;
     }
 
     // go through the columns
     Vec_PtrForEachEntry( Vec_Ptr_t *, p->vBuckets, vBucket, i )
     Vec_PtrForEachEntry( Vec_Int_t *, vBucket, vInput, j )
     {
         Vec_IntForEachEntryStart( vInput, ObjId, k, SHARE_NUM )
         {
             assert( ObjId < Vec_IntSize(p->vObj2Lit) );
             if ( ObjId >= p->nStartCols )
                 break;
             assert( ObjId < p->nStartCols );
             iLit = Vec_IntEntry( vInput, 0 );
 
             pNew = (Abc_Obj_t *)Vec_PtrEntry( vRepl, ObjId );
             if ( fAnd )
                 pNew = Abc_AigAnd( (Abc_Aig_t *)p->pNtk->pManFunc, pNew, Abc_ObjFromLit(p->pNtk, iLit) );
             else
                 pNew = Abc_AigXor( (Abc_Aig_t *)p->pNtk->pManFunc, pNew, Abc_ObjFromLit(p->pNtk, iLit) );
             Vec_PtrWriteEntry( vRepl, ObjId, pNew );
             p->nCountGates++;
         }
     }
 
     if ( p->fVerbose )
         printf( "Total gates collected = %d.  Total gates constructed = %d.\n", p->nFoundGates, p->nCountGates );
 
     // create map of originals
     vMap2Repl = Vec_IntStartFull( Abc_NtkObjNumMax(p->pNtk) );
     Vec_PtrForEachEntry( Abc_Obj_t *, vOrig, pObj, i )
     {
 //        printf( "Replacing %d by %d.\n", Abc_ObjId(pObj), Abc_ObjToLit((Abc_Obj_t *)Vec_PtrEntry(vRepl, i)) );
         Vec_IntWriteEntry( vMap2Repl, Abc_ObjId(pObj), Abc_ObjToLit((Abc_Obj_t *)Vec_PtrEntry(vRepl, i)) );
     }
     Vec_PtrFree( vOrig );
     Vec_PtrFree( vRepl );
 
     // update fanin pointers
     Abc_NtkForEachObj( p->pNtk, pObj, i )
     {
         if ( Abc_ObjIsCo(pObj) || Abc_ObjIsNode(pObj) )
         {
             iLit = Vec_IntEntry( vMap2Repl, Abc_ObjFaninId0(pObj) );
             if ( iLit >= 0 )
             {
                 if ( iLit == iLitConst1 && fAnd )
                 {
                     pObj->fCompl0 ^= 1;
                     Vec_IntWriteEntry( &pObj->vFanins, 0, Abc_Lit2Var(iLitConst1) );
                 }
                 else
                 {
                     pObj->fCompl0 ^= Abc_LitIsCompl(iLit);
                     Vec_IntWriteEntry( &pObj->vFanins, 0, Abc_Lit2Var(iLit) );
                 }
             }
         }
         if ( Abc_ObjIsNode(pObj) )
         {
             iLit = Vec_IntEntry( vMap2Repl, Abc_ObjFaninId1(pObj) );
             if ( iLit >= 0 )
             {
                 if ( iLit == iLitConst1 && fAnd )
                 {
                     pObj->fCompl1 ^= 1;
                     Vec_IntWriteEntry( &pObj->vFanins, 1, Abc_Lit2Var(iLitConst1) );
                 }
                 else
                 {
                     pObj->fCompl1 ^= Abc_LitIsCompl(iLit);
                     Vec_IntWriteEntry( &pObj->vFanins, 1, Abc_Lit2Var(iLit) );
                 }
             }
         }
     }
     Vec_IntFree( vMap2Repl );
 
 //    pNtk = Abc_NtkRestrash( p->pNtk, 1 );
     if ( fAnd )
         pNtk = Abc_NtkBalance( p->pNtk, 0, 0, 1 );
     else
         pNtk = Abc_NtkBalanceExor( p->pNtk, 1, 0 );
     return pNtk;
 }

Abc_ShaMan_t* Abc_ShaManStart ( Abc_Ntk_t * pNtk )

FUNCTION DEFINITIONS ///.

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

Synopsis [Working with the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 64 of file abcExtract.c.

 {
     Abc_ShaMan_t * p;
     p = ABC_CALLOC( Abc_ShaMan_t, 1 );
     p->pNtk      = pNtk;
     p->vObj2Lit  = Vec_IntAlloc( 1000 );
     return p;
 }

void Abc_ShaManStop ( Abc_ShaMan_t * p )

Definition at line 72 of file abcExtract.c.

 {
     Vec_Ptr_t * vBucket;
     int i;
     Vec_PtrForEachEntry( Vec_Ptr_t *, p->vBuckets, vBucket, i )
         Vec_VecFree( (Vec_Vec_t *)vBucket );
     Vec_PtrFreeP( &p->vBuckets );
     Vec_IntFreeP( &p->vObj2Lit );
     ABC_FREE( p );
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation