giaIso2.c File Reference

#include "gia.h"
#include "misc/vec/vecHsh.h"
#include "misc/vec/vecWec.h"

Go to the source code of this file.

Data Structures
struct	Gia_Iso2Man_t_

Macros
#define	ISO_MASK   0xFF

Typedefs
typedef struct Gia_Iso2Man_t_	Gia_Iso2Man_t
	DECLARATIONS ///. More...

Functions
Vec_Int_t *	Gia_Iso2ManCollectTies (Gia_Man_t *p)
	FUNCTION DEFINITIONS ///. More...
void	Gia_Iso2ManPrepare (Gia_Man_t *p)
void	Gia_Iso2ManPropagate (Gia_Man_t *p)
unsigned	Gia_Iso2ManCone_rec (Gia_Man_t *p, int Id, int Level)
unsigned	Gia_Iso2ManCone (Gia_Man_t *p, int Id, int Level)
void	Gia_Iso2ManUpdate (Gia_Iso2Man_t *p, int Level)
Gia_Iso2Man_t *	Gia_Iso2ManStart (Gia_Man_t *pGia)
void	Gia_Iso2ManStop (Gia_Iso2Man_t *p)
void	Gia_Iso2ManPrint (Gia_Iso2Man_t *p, abctime Time, int fVerbose)
int	Gia_ObjCompareByValue2 (Gia_Obj_t **pp1, Gia_Obj_t **pp2)
int	Gia_Iso2ManUniqify (Gia_Iso2Man_t *p)
Vec_Wec_t *	Gia_Iso2ManDerivePoClasses (Gia_Man_t *pGia)
void	Gia_Iso2ManCollectOrder2_rec (Gia_Man_t *p, int Id, Vec_Int_t *vVec)
Vec_Int_t *	Gia_Iso2ManCollectOrder2 (Gia_Man_t *pGia, int *pPos, int nPos)
void	Gia_Iso2ManCollectOrder_rec (Gia_Man_t *p, int Id, Vec_Int_t *vRoots, Vec_Int_t *vVec, Vec_Int_t *vMap)
void	Gia_Iso2ManCollectOrder (Gia_Man_t *pGia, int *pPos, int nPos, Vec_Int_t *vRoots, Vec_Int_t *vVec, Vec_Int_t *vMap)
int	Gia_Iso2ManCheckIsoPair (Gia_Man_t *p, Vec_Int_t *vVec0, Vec_Int_t *vVec1, Vec_Int_t *vMap0, Vec_Int_t *vMap1)
int	Gia_Iso2ManCheckIsoClassOneSkip (Gia_Man_t *p, Vec_Int_t *vClass, Vec_Int_t *vRoots, Vec_Int_t *vVec0, Vec_Int_t *vVec1, Vec_Int_t *vMap0, Vec_Int_t *vMap1)
Vec_Wec_t *	Gia_Iso2ManCheckIsoClassesSkip (Gia_Man_t *p, Vec_Wec_t *vEquivs)
void	Gia_Iso2ManCheckIsoClassOne (Gia_Man_t *p, Vec_Int_t *vClass, Vec_Int_t *vRoots, Vec_Int_t *vVec0, Vec_Int_t *vVec1, Vec_Int_t *vMap0, Vec_Int_t *vMap1, Vec_Int_t *vNewClass)
Vec_Wec_t *	Gia_Iso2ManCheckIsoClasses (Gia_Man_t *p, Vec_Wec_t *vEquivs)
Vec_Wec_t *	Gia_Iso2ManPerform (Gia_Man_t *pGia, int fVerbose)
Gia_Man_t *	Gia_ManIsoReduce2 (Gia_Man_t *pGia, Vec_Ptr_t **pvPosEquivs, Vec_Ptr_t **pvPiPerms, int fEstimate, int fBetterQual, int fDualOut, int fVerbose, int fVeryVerbose)

Variables
static int	s_256Primes [ISO_MASK+1]
static int	s_PrimeC = 49

Macro Definition Documentation

#define ISO_MASK   0xFF

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

FileName [gia.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis []

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

]

Definition at line 29 of file giaIso2.c.

Typedef Documentation

typedef struct Gia_Iso2Man_t_ Gia_Iso2Man_t

DECLARATIONS ///.

Definition at line 73 of file giaIso2.c.

Function Documentation

Vec_Wec_t* Gia_Iso2ManCheckIsoClasses	(	Gia_Man_t *	p,
		Vec_Wec_t *	vEquivs
	)

Definition at line 628 of file giaIso2.c.

{
    Vec_Wec_t * vEquivs2;
    Vec_Int_t * vRoots = Vec_IntAlloc( 10000 );
    Vec_Int_t * vVec0 = Vec_IntAlloc( 10000 );
    Vec_Int_t * vVec1 = Vec_IntAlloc( 10000 );
    Vec_Int_t * vMap0 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vMap1 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vClass, * vClass2, * vNewClass;
    int i, Counter = 0;
    vNewClass = Vec_IntAlloc( 100 );
    vEquivs2 = Vec_WecAlloc( 2 * Vec_WecSize(vEquivs) );
    Vec_WecForEachLevel( vEquivs, vClass, i )
    {
        if ( i % 50 == 0 )
            printf( "Finished %8d outputs (out of %8d)...\r", Counter, Gia_ManPoNum(p) ), fflush(stdout);
        // split this class
        Gia_Iso2ManCheckIsoClassOne( p, vClass, vRoots, vVec0, vVec1, vMap0, vMap1, vNewClass );
        Counter += Vec_IntSize(vClass);
        // add remaining class
        vClass2 = Vec_WecPushLevel( vEquivs2 );
        *vClass2 = *vClass;
        vClass->pArray = NULL;
        vClass->nSize = vClass->nCap = 0;
        // add new class
        if ( Vec_IntSize(vNewClass) == 0 )
            continue;
        vClass = Vec_WecPushLevel( vEquivs );
        Vec_IntAppend( vClass, vNewClass );
    }
    Vec_IntFree( vNewClass );   
    Vec_IntFree( vRoots );
    Vec_IntFree( vVec0 );
    Vec_IntFree( vVec1 );
    Vec_IntFree( vMap0 );
    Vec_IntFree( vMap1 );
    return vEquivs2;
}

Vec_Wec_t* Gia_Iso2ManCheckIsoClassesSkip	(	Gia_Man_t *	p,
		Vec_Wec_t *	vEquivs
	)

Definition at line 569 of file giaIso2.c.

{
    Vec_Wec_t * vEquivs2;
    Vec_Int_t * vRoots = Vec_IntAlloc( 10000 );
    Vec_Int_t * vVec0 = Vec_IntAlloc( 10000 );
    Vec_Int_t * vVec1 = Vec_IntAlloc( 10000 );
    Vec_Int_t * vMap0 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vMap1 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vClass, * vClass2;
    int i, k, Entry, Counter = 0;
    vEquivs2 = Vec_WecAlloc( 2 * Vec_WecSize(vEquivs) );
    Vec_WecForEachLevel( vEquivs, vClass, i )
    {
        if ( i % 50 == 0 )
            printf( "Finished %8d outputs (out of %8d)...\r", Counter, Gia_ManPoNum(p) ), fflush(stdout);
        Counter += Vec_IntSize(vClass);
        if ( Vec_IntSize(vClass) < 2 || Gia_Iso2ManCheckIsoClassOneSkip(p, vClass, vRoots, vVec0, vVec1, vMap0, vMap1) )
        {
            vClass2 = Vec_WecPushLevel( vEquivs2 );
            *vClass2 = *vClass;
            vClass->pArray = NULL;
            vClass->nSize = vClass->nCap = 0;
        }
        else
        {
            Vec_IntForEachEntry( vClass, Entry, k )
            {
                vClass2 = Vec_WecPushLevel( vEquivs2 );
                Vec_IntPush( vClass2, Entry );
            }
        }
    }
    Vec_IntFree( vRoots );
    Vec_IntFree( vVec0 );
    Vec_IntFree( vVec1 );
    Vec_IntFree( vMap0 );
    Vec_IntFree( vMap1 );
    return vEquivs2;
}

void Gia_Iso2ManCheckIsoClassOne	(	Gia_Man_t *	p,
		Vec_Int_t *	vClass,
		Vec_Int_t *	vRoots,
		Vec_Int_t *	vVec0,
		Vec_Int_t *	vVec1,
		Vec_Int_t *	vMap0,
		Vec_Int_t *	vMap1,
		Vec_Int_t *	vNewClass
	)

Definition at line 609 of file giaIso2.c.

{
    int i, k = 1, iPo;
    Vec_IntClear( vNewClass );
    if ( Vec_IntSize(vClass) <= 1 )
        return;
    assert( Vec_IntSize(vClass) > 1 );
    iPo = Vec_IntEntry( vClass, 0 );
    Gia_Iso2ManCollectOrder( p, &iPo, 1, vRoots, vVec0, vMap0 );
    Vec_IntForEachEntryStart( vClass, iPo, i, 1 )
    {
        Gia_Iso2ManCollectOrder( p, &iPo, 1, vRoots, vVec1, vMap1 );
        if ( Vec_IntSize(vVec0) == Vec_IntSize(vVec1) && Gia_Iso2ManCheckIsoPair(p, vVec0, vVec1, vMap0, vMap1) )
            Vec_IntWriteEntry( vClass, k++, iPo );
        else
            Vec_IntPush( vNewClass, iPo );
    }
    Vec_IntShrink( vClass, k );
} 

int Gia_Iso2ManCheckIsoClassOneSkip	(	Gia_Man_t *	p,
		Vec_Int_t *	vClass,
		Vec_Int_t *	vRoots,
		Vec_Int_t *	vVec0,
		Vec_Int_t *	vVec1,
		Vec_Int_t *	vMap0,
		Vec_Int_t *	vMap1
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 553 of file giaIso2.c.

{
    int i, iPo;
    assert( Vec_IntSize(vClass) > 1 );
    iPo = Vec_IntEntry( vClass, 0 );
    Gia_Iso2ManCollectOrder( p, &iPo, 1, vRoots, vVec0, vMap0 );
    Vec_IntForEachEntryStart( vClass, iPo, i, 1 )
    {
        Gia_Iso2ManCollectOrder( p, &iPo, 1, vRoots, vVec1, vMap1 );
        if ( Vec_IntSize(vVec0) != Vec_IntSize(vVec1) )
            return 0;
        if ( !Gia_Iso2ManCheckIsoPair( p, vVec0, vVec1, vMap0, vMap1 ) )
            return 0;
    }
    return 1;
} 

int Gia_Iso2ManCheckIsoPair	(	Gia_Man_t *	p,
		Vec_Int_t *	vVec0,
		Vec_Int_t *	vVec1,
		Vec_Int_t *	vMap0,
		Vec_Int_t *	vMap1
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 489 of file giaIso2.c.

{
    Gia_Obj_t * pObj0, * pObj1;
    int k, iObj0, iObj1;
    Vec_IntForEachEntryTwo( vVec0, vVec1, iObj0, iObj1, k )
    {
        if ( iObj0 == iObj1 )
            continue;
        pObj0 = Gia_ManObj(p, iObj0);
        pObj1 = Gia_ManObj(p, iObj1);
        if ( pObj0->Value != pObj1->Value )
            return 0;
        assert( pObj0->Value == pObj1->Value );
        if ( !Gia_ObjIsAnd(pObj0) )
            continue;
        if ( Gia_ObjFanin0(pObj0)->Value <= Gia_ObjFanin1(pObj0)->Value )
        {
            if ( Gia_ObjFanin0(pObj1)->Value <= Gia_ObjFanin1(pObj1)->Value )
            {
                if ( Gia_ObjFaninC0(pObj0) != Gia_ObjFaninC0(pObj1)  || Gia_ObjFaninC1(pObj0) != Gia_ObjFaninC1(pObj1)   ||
                     Vec_IntEntry(vMap0, Gia_ObjFaninId0p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId0p(p, pObj1)) || 
                     Vec_IntEntry(vMap0, Gia_ObjFaninId1p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId1p(p, pObj1)) )
                     return 0;
            }
            else
            {
                if ( Gia_ObjFaninC0(pObj0) != Gia_ObjFaninC1(pObj1)  || Gia_ObjFaninC1(pObj0) != Gia_ObjFaninC0(pObj1)   ||
                     Vec_IntEntry(vMap0, Gia_ObjFaninId0p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId1p(p, pObj1)) || 
                     Vec_IntEntry(vMap0, Gia_ObjFaninId1p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId0p(p, pObj1)) )
                     return 0;
            }
        }
        else
        {
            if ( Gia_ObjFanin0(pObj1)->Value <= Gia_ObjFanin1(pObj1)->Value )
            {
                if ( Gia_ObjFaninC1(pObj0) != Gia_ObjFaninC0(pObj1)  || Gia_ObjFaninC0(pObj0) != Gia_ObjFaninC1(pObj1)   ||
                     Vec_IntEntry(vMap0, Gia_ObjFaninId1p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId0p(p, pObj1)) || 
                     Vec_IntEntry(vMap0, Gia_ObjFaninId0p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId1p(p, pObj1)) )
                     return 0;
            }
            else
            {
                if ( Gia_ObjFaninC1(pObj0) != Gia_ObjFaninC1(pObj1)  || Gia_ObjFaninC0(pObj0) != Gia_ObjFaninC0(pObj1)   ||
                     Vec_IntEntry(vMap0, Gia_ObjFaninId1p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId1p(p, pObj1)) || 
                     Vec_IntEntry(vMap0, Gia_ObjFaninId0p(p, pObj0)) != Vec_IntEntry( vMap1, Gia_ObjFaninId0p(p, pObj1)) )
                     return 0;
            }
        }
    }
    return 1;
} 

void Gia_Iso2ManCollectOrder	(	Gia_Man_t *	pGia,
		int *	pPos,
		int	nPos,
		Vec_Int_t *	vRoots,
		Vec_Int_t *	vVec,
		Vec_Int_t *	vMap
	)

Definition at line 466 of file giaIso2.c.

{
    int i, iRoot;
    Vec_IntClear( vRoots );
    for ( i = 0; i < nPos; i++ )
        Vec_IntPush( vRoots, Gia_ObjId(pGia, Gia_ManPo(pGia, pPos[i])) );
    Vec_IntClear( vVec );
    Gia_ManIncrementTravId( pGia );
    Vec_IntForEachEntry( vRoots, iRoot, i )
        Gia_Iso2ManCollectOrder_rec( pGia, iRoot, vRoots, vVec, vMap );
}

Vec_Int_t* Gia_Iso2ManCollectOrder2	(	Gia_Man_t *	pGia,
		int *	pPos,
		int	nPos
	)

Definition at line 411 of file giaIso2.c.

{
    Vec_Int_t * vVec;
    int i;
    vVec = Vec_IntAlloc( 1000 );
    Gia_ManIncrementTravId( pGia );
    for ( i = 0; i < nPos; i++ )
        Gia_Iso2ManCollectOrder2_rec( pGia, Gia_ObjId(pGia, Gia_ManPo(pGia, pPos[i])), vVec );
    return vVec;
}

void Gia_Iso2ManCollectOrder2_rec	(	Gia_Man_t *	p,
		int	Id,
		Vec_Int_t *	vVec
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 381 of file giaIso2.c.

{
    Gia_Obj_t * pObj;
    if ( Gia_ObjIsTravIdCurrentId(p, Id) )
        return;
    Gia_ObjSetTravIdCurrentId(p, Id);
    pObj = Gia_ManObj( p, Id );
    if ( Gia_ObjIsAnd(pObj) )
    {
        if ( Gia_ObjFanin0(pObj)->Value <= Gia_ObjFanin1(pObj)->Value )
        {
            Gia_Iso2ManCollectOrder2_rec( p, Gia_ObjFaninId0(pObj, Id), vVec );
            Gia_Iso2ManCollectOrder2_rec( p, Gia_ObjFaninId1(pObj, Id), vVec );
        }
        else
        {
            Gia_Iso2ManCollectOrder2_rec( p, Gia_ObjFaninId1(pObj, Id), vVec );
            Gia_Iso2ManCollectOrder2_rec( p, Gia_ObjFaninId0(pObj, Id), vVec );
        }
    }
    else if ( Gia_ObjIsCo(pObj) )
    {
        Gia_Iso2ManCollectOrder2_rec( p, Gia_ObjFaninId0(pObj, Id), vVec );
    }
    else if ( Gia_ObjIsPi(p, pObj) )
    {
    }
    else assert( Gia_ObjIsConst0(pObj) );
    Vec_IntPush( vVec, Id );
}

void Gia_Iso2ManCollectOrder_rec	(	Gia_Man_t *	p,
		int	Id,
		Vec_Int_t *	vRoots,
		Vec_Int_t *	vVec,
		Vec_Int_t *	vMap
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 433 of file giaIso2.c.

{
    Gia_Obj_t * pObj;
    if ( Gia_ObjIsTravIdCurrentId(p, Id) )
        return;
    Gia_ObjSetTravIdCurrentId(p, Id);
    pObj = Gia_ManObj( p, Id );
    if ( Gia_ObjIsAnd(pObj) )
    {
        if ( Gia_ObjFanin0(pObj)->Value <= Gia_ObjFanin1(pObj)->Value )
        {
            Gia_Iso2ManCollectOrder_rec( p, Gia_ObjFaninId0(pObj, Id), vRoots, vVec, vMap );
            Gia_Iso2ManCollectOrder_rec( p, Gia_ObjFaninId1(pObj, Id), vRoots, vVec, vMap );
        }
        else
        {
            Gia_Iso2ManCollectOrder_rec( p, Gia_ObjFaninId1(pObj, Id), vRoots, vVec, vMap );
            Gia_Iso2ManCollectOrder_rec( p, Gia_ObjFaninId0(pObj, Id), vRoots, vVec, vMap );
        }
    }
    else if ( Gia_ObjIsCo(pObj) )
    {
        Gia_Iso2ManCollectOrder_rec( p, Gia_ObjFaninId0(pObj, Id), vRoots, vVec, vMap );
    }
    else if ( Gia_ObjIsCi(pObj) )
    {
        if ( Gia_ObjIsRo(p, pObj) )
            Vec_IntPush( vRoots, Gia_ObjId(p, Gia_ObjRoToRi(p, pObj)) );
    }
    else assert( Gia_ObjIsConst0(pObj) );
    Vec_IntWriteEntry( vMap, Id, Vec_IntSize(vVec) );
    Vec_IntPush( vVec, Id );
}

Vec_Int_t* Gia_Iso2ManCollectTies

(

Gia_Man_t *

p

)

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 115 of file giaIso2.c.

{
    Vec_Int_t * vTies;
    Gia_Obj_t * pObj;
    int i;
    vTies = Vec_IntAlloc( Gia_ManCandNum(p) );
    Gia_ManForEachCand( p, pObj, i )
        Vec_IntPush( vTies, i );
    return vTies;
}

unsigned Gia_Iso2ManCone	(	Gia_Man_t *	p,
		int	Id,
		int	Level
	)

Definition at line 190 of file giaIso2.c.

{
    Gia_ManIncrementTravId( p );
    return Gia_Iso2ManCone_rec( p, Id, Level );
}

unsigned Gia_Iso2ManCone_rec	(	Gia_Man_t *	p,
		int	Id,
		int	Level
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 172 of file giaIso2.c.

{
    Gia_Obj_t * pObj;
    if ( Level == 0 )
        return 0;
    if ( Gia_ObjIsTravIdCurrentId(p, Id) )
        return 0;
    Gia_ObjSetTravIdCurrentId(p, Id);
    pObj = Gia_ManObj( p, Id );
    if ( Gia_ObjIsAnd(pObj) )
        return pObj->Value + Gia_Iso2ManCone_rec( p, Gia_ObjFaninId0(pObj, Id), Level-1 ) + Gia_Iso2ManCone_rec( p, Gia_ObjFaninId1(pObj, Id), Level-1 );
    if ( Gia_ObjIsPi(p, pObj) )
        return pObj->Value;
    if ( Gia_ObjIsRo(p, pObj) )
        return pObj->Value + Gia_Iso2ManCone_rec( p, Gia_ObjId(p, Gia_ObjFanin0(Gia_ObjRoToRi(p, pObj))), Level );
    assert( Gia_ObjIsConst0(pObj) );
    return pObj->Value;
}

Vec_Wec_t* Gia_Iso2ManDerivePoClasses

(

Gia_Man_t *

pGia

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 353 of file giaIso2.c.

{
    Vec_Wec_t * vEquivs;
    Vec_Int_t * vValues;
    Vec_Int_t * vMap;
    Gia_Obj_t * pObj;
    int i;
    vValues = Vec_IntAlloc( Gia_ManPoNum(pGia) );
    Gia_ManForEachPo( pGia, pObj, i )
        Vec_IntPush( vValues, pObj->Value );
    vMap = Hsh_IntManHashArray( vValues, 1 );
    Vec_IntFree( vValues );
    vEquivs = Vec_WecCreateClasses( vMap );
    Vec_IntFree( vMap );
    return vEquivs;    
}

Vec_Wec_t* Gia_Iso2ManPerform	(	Gia_Man_t *	pGia,
		int	fVerbose
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 680 of file giaIso2.c.

{
    Gia_Iso2Man_t * p;
    abctime clk = Abc_Clock();
    p = Gia_Iso2ManStart( pGia );
    Gia_Iso2ManPrepare( pGia );
    Gia_Iso2ManPropagate( pGia );
    Gia_Iso2ManPrint( p, Abc_Clock() - clk, fVerbose );
    while ( Gia_Iso2ManUniqify( p ) )
    {
        Gia_Iso2ManPrint( p, Abc_Clock() - clk, fVerbose );
        Gia_Iso2ManPropagate( pGia );
    }
    Gia_Iso2ManPrint( p, Abc_Clock() - clk, fVerbose );
/*
    Gia_Iso2ManUpdate( p, 20 );
    while ( Gia_Iso2ManUniqify( p ) )
    {
        Gia_Iso2ManPrint( p, Abc_Clock() - clk, fVerbose );
        Gia_Iso2ManPropagate( pGia );
    }
    Gia_Iso2ManPrint( p, Abc_Clock() - clk, fVerbose );
*/
    Gia_Iso2ManStop( p );
    return Gia_Iso2ManDerivePoClasses( pGia );
}

void Gia_Iso2ManPrepare

(

Gia_Man_t *

p

)

Definition at line 125 of file giaIso2.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->Value = Gia_ObjIsAnd(pObj) ? 1 + Abc_MaxInt(Gia_ObjFanin0(pObj)->Value, Gia_ObjFanin1(pObj)->Value) : 0;
    Gia_ManConst0(p)->Value = s_256Primes[ISO_MASK];
    Gia_ManForEachObj1( p, pObj, i )
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = s_256Primes[pObj->Value & ISO_MASK] + s_256Primes[ISO_MASK - 10 + Gia_ObjFaninC0(pObj) + Gia_ObjFaninC1(pObj)];
        else if ( Gia_ObjIsPi(p, pObj) )
            pObj->Value = s_256Primes[ISO_MASK-1];
        else if ( Gia_ObjIsRo(p, pObj) )
            pObj->Value = s_256Primes[ISO_MASK-2];
}

void Gia_Iso2ManPrint	(	Gia_Iso2Man_t *	p,
		abctime	Time,
		int	fVerbose
	)

Definition at line 248 of file giaIso2.c.

{
    if ( !fVerbose )
        return;
    printf( "Iter %4d :  ", p->nIters++ );
    printf( "Entries =%8d.  ", Vec_IntSize(p->vTied) );
    printf( "Uniques =%8d.  ", p->nUniques );
    printf( "Singles =%8d.  ", Vec_PtrSize(p->vSingles) );
    printf( "%9.2f sec", (float)(Time)/(float)(CLOCKS_PER_SEC) );
    printf( "\n" );
    fflush( stdout );
}

void Gia_Iso2ManPropagate

(

Gia_Man_t *

p

)

Definition at line 140 of file giaIso2.c.

{
    Gia_Obj_t * pObj, * pObjRo;
    int i;
    Gia_ManForEachObj1( p, pObj, i )
        if ( Gia_ObjIsAnd(pObj) )
        {
            pObj->Value += (Gia_ObjFaninC0(pObj) + s_PrimeC) * Gia_ObjFanin0(pObj)->Value + (Gia_ObjFaninC1(pObj) + s_PrimeC) * Gia_ObjFanin1(pObj)->Value;
            if ( Gia_ObjFaninC0(pObj) == Gia_ObjFaninC1(pObj) && Gia_ObjFanin0(pObj)->Value == Gia_ObjFanin1(pObj)->Value )
                pObj->Value += s_256Primes[ISO_MASK - 11];
        }
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value += (Gia_ObjFaninC0(pObj) + s_PrimeC) * Gia_ObjFanin0(pObj)->Value;
    Gia_ManForEachRiRo( p, pObj, pObjRo, i )
    {
        pObjRo->Value += pObj->Value;
        if ( pObjRo == Gia_ObjFanin0(pObj) )
            pObjRo->Value += s_256Primes[ISO_MASK - 12];
    }
}

Gia_Iso2Man_t* Gia_Iso2ManStart

(

Gia_Man_t *

pGia

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 214 of file giaIso2.c.

{
    Gia_Iso2Man_t * p;
    p = ABC_CALLOC( Gia_Iso2Man_t, 1 );
    p->pGia      = pGia;
    p->nObjs     = Gia_ManObjNum( pGia );
    p->nUniques  = 0;
    // internal data
    p->vUniques  = Vec_IntStartFull( p->nObjs );
    p->vTied     = Gia_Iso2ManCollectTies( pGia );
    p->vTable    = Vec_IntStart( Abc_PrimeCudd(1*p->nObjs) );
    p->vPlaces   = Vec_IntAlloc( 1000 );
    p->vSingles  = Vec_PtrAlloc( 1000 );
    p->vVec0     = Vec_IntAlloc( 10000 );
    p->vVec1     = Vec_IntAlloc( 10000 );
    p->vMap0     = Vec_IntStart( p->nObjs );
    p->vMap1     = Vec_IntStart( p->nObjs );
    // add constant 0 object
    Vec_IntWriteEntry( p->vUniques, 0, p->nUniques++ );
    return p;
}

void Gia_Iso2ManStop

(

Gia_Iso2Man_t *

p

)

Definition at line 235 of file giaIso2.c.

{
    Vec_IntFree( p->vUniques );
    Vec_IntFree( p->vTied );
    Vec_IntFree( p->vTable );
    Vec_IntFree( p->vPlaces );
    Vec_PtrFree( p->vSingles );
    Vec_IntFree( p->vMap0 );
    Vec_IntFree( p->vMap1 );
    Vec_IntFree( p->vVec0 );
    Vec_IntFree( p->vVec1 );
    ABC_FREE( p );
}

int Gia_Iso2ManUniqify

(

Gia_Iso2Man_t *

p

)

Definition at line 276 of file giaIso2.c.

{
    int fVerify = 0;
    Gia_Obj_t * pObj, * pTemp;
    int * pTable = Vec_IntArray(p->vTable);
    int i, k, nSize = Vec_IntSize(p->vTable);

    if ( fVerify )
        for ( k = 0; k < nSize; k++ )
            assert( pTable[k] == 0 );
    if ( fVerify )
        Gia_ManForEachObjVec( p->vTied, p->pGia, pObj, i )
            assert( pObj->fMark0 == 0 );

#if 0
    Gia_ManForEachObjVec( p->vTied, p->pGia, pObj, i )
    {
        printf( "%3d : ", Gia_ObjId(p->pGia, pObj) );
        Extra_PrintBinary( stdout, &pObj->Value, 32 );
        printf( "\n" );
    }
#endif

    // add objects to the table
    Vec_IntClear( p->vPlaces );
    Gia_ManForEachObjVec( p->vTied, p->pGia, pObj, i )
    {
        for ( k = pObj->Value % nSize; (pTemp = pTable[k] ? Gia_ManObj(p->pGia, pTable[k]) : NULL); k = (k + 1) % nSize )
            if ( pTemp->Value == pObj->Value )
            {
                pTemp->fMark0 = 1;
                pObj->fMark0 = 1;
                break;
            }
        if ( pTemp != NULL )
            continue;
        pTable[k] = Gia_ObjId(p->pGia, pObj);
        Vec_IntPush( p->vPlaces, k );
    }
    // clean the table
    Vec_IntForEachEntry( p->vPlaces, k, i )
        pTable[k] = 0;
    // collect singleton objects and compact tied objects
    k = 0;
    Vec_PtrClear( p->vSingles );
    Gia_ManForEachObjVec( p->vTied, p->pGia, pObj, i )
        if ( pObj->fMark0 == 0 )
            Vec_PtrPush( p->vSingles, pObj );
        else 
        {
            pObj->fMark0 = 0;
            Vec_IntWriteEntry( p->vTied, k++, Gia_ObjId(p->pGia, pObj) );
        }
    Vec_IntShrink( p->vTied, k );
    // sort singletons
    Vec_PtrSort( p->vSingles, (int (*)(void))Gia_ObjCompareByValue2 );
    // add them to unique and increment signature
    Vec_PtrForEachEntry( Gia_Obj_t *, p->vSingles, pObj, i )
    {
        pObj->Value += s_256Primes[p->nUniques & ISO_MASK];
        assert( Vec_IntEntry(p->vUniques, Gia_ObjId(p->pGia, pObj)) == -1 );
        Vec_IntWriteEntry( p->vUniques, Gia_ObjId(p->pGia, pObj), p->nUniques++ );
    }
    return Vec_PtrSize( p->vSingles );
}

void Gia_Iso2ManUpdate	(	Gia_Iso2Man_t *	p,
		int	Level
	)

Definition at line 195 of file giaIso2.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObjVec( p->vTied, p->pGia, pObj, i )
        pObj->Value += Gia_Iso2ManCone( p->pGia, Gia_ObjId(p->pGia, pObj), Level );
}

Gia_Man_t* Gia_ManIsoReduce2	(	Gia_Man_t *	pGia,
		Vec_Ptr_t **	pvPosEquivs,
		Vec_Ptr_t **	pvPiPerms,
		int	fEstimate,
		int	fBetterQual,
		int	fDualOut,
		int	fVerbose,
		int	fVeryVerbose
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 718 of file giaIso2.c.

{
    Gia_Man_t * pPart;
    Vec_Wec_t * vEquivs, * vEquivs2;
    Vec_Int_t * vRemains;
    int nClasses, nUsedPos;
    abctime clk = Abc_Clock();
    vEquivs = Gia_Iso2ManPerform( pGia, fVeryVerbose );
    // report class stats
    nClasses = Vec_WecCountNonTrivial( vEquivs, &nUsedPos );
    printf( "Reduced %d outputs to %d candidate   classes (%d outputs are in %d non-trivial classes).  ", 
        Gia_ManPoNum(pGia), Vec_WecSize(vEquivs), nUsedPos, nClasses );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    if ( fEstimate )
    {
        Vec_WecFree( vEquivs );
        return Gia_ManDup(pGia);
    }
    // verify classes
    if ( fBetterQual )
        vEquivs2 = Gia_Iso2ManCheckIsoClasses( pGia, vEquivs );
    else
        vEquivs2 = Gia_Iso2ManCheckIsoClassesSkip( pGia, vEquivs );
    Vec_WecFree( vEquivs );
    vEquivs = vEquivs2;
    // sort equiv classes by the first integer
    Vec_WecSortByFirstInt( vEquivs, 0 );
    // find the first outputs
    vRemains = Vec_WecCollectFirsts( vEquivs );
    // derive the final GIA
    pPart = Gia_ManDupCones( pGia, Vec_IntArray(vRemains), Vec_IntSize(vRemains), 0 );
    Vec_IntFree( vRemains );
    // report class stats
    nClasses = Vec_WecCountNonTrivial( vEquivs, &nUsedPos );
    printf( "Reduced %d outputs to %d equivalence classes (%d outputs are in %d non-trivial classes).  ", 
        Gia_ManPoNum(pGia), Vec_WecSize(vEquivs), nUsedPos, nClasses );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    if ( fVerbose )
    { 
        printf( "Nontrivial classes:\n" );
        Vec_WecPrint( vEquivs, 1 );
    }
    if ( pvPiPerms )
        *pvPiPerms = NULL;
    if ( pvPosEquivs )
        *pvPosEquivs = Vec_WecConvertToVecPtr( vEquivs );
    Vec_WecFree( vEquivs );
//    Gia_ManStopP( &pPart );
    return pPart;
}

int Gia_ObjCompareByValue2	(	Gia_Obj_t **	pp1,
		Gia_Obj_t **	pp2
	)

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

Synopsis [Uniqifies objects using their signature.]

Description [Assumes the tied objects are in p->vTied. Assumes that updated signature (pObj->Value) is assigned to these objects. Returns the array of unique objects p->vSingles sorted by signature. Compacts the array of tied objects p->vTied.]

SideEffects []

SeeAlso []

Definition at line 275 of file giaIso2.c.

{ return (int)(*pp1)->Value - (int)(*pp2)->Value; }

Variable Documentation

int s_256Primes[ISO_MASK+1]

static

Definition at line 30 of file giaIso2.c.

int s_PrimeC = 49

static

Definition at line 66 of file giaIso2.c.