giaUtil.c File Reference

#include "gia.h"
#include "base/main/mainInt.h"

Include dependency graph for giaUtil.c:

Go to the source code of this file.

Classes
struct	Gia_MapLut_t_

Macros
#define	NUMBER1   3716960521u
	DECLARATIONS ///.
#define	NUMBER2   2174103536u
#define	MAX_LUT_SIZE   8

Typedefs
typedef struct Gia_MapLut_t_	Gia_MapLut_t

Functions
unsigned	Gia_ManRandom (int fReset)
	FUNCTION DEFINITIONS ///.
word	Gia_ManRandomW (int fReset)
void	Gia_ManRandomInfo (Vec_Ptr_t *vInfo, int iInputStart, int iWordStart, int iWordStop)
char *	Gia_TimeStamp ()
char *	Gia_FileNameGenericAppend (char *pBase, char *pSuffix)
Vec_Ptr_t *	Gia_GetFakeNames (int nNames, int fCaps)
void	Gia_ManIncrementTravId (Gia_Man_t *p)
void	Gia_ManCleanMark01 (Gia_Man_t *p)
void	Gia_ManSetMark0 (Gia_Man_t *p)
void	Gia_ManCleanMark0 (Gia_Man_t *p)
void	Gia_ManCheckMark0 (Gia_Man_t *p)
void	Gia_ManSetMark1 (Gia_Man_t *p)
void	Gia_ManCleanMark1 (Gia_Man_t *p)
void	Gia_ManCheckMark1 (Gia_Man_t *p)
void	Gia_ManCleanValue (Gia_Man_t *p)
void	Gia_ManFillValue (Gia_Man_t *p)
void	Gia_ObjSetPhase (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ManSetPhase (Gia_Man_t *p)
void	Gia_ManSetPhasePattern (Gia_Man_t *p, Vec_Int_t *vCiValues)
void	Gia_ManSetPhase1 (Gia_Man_t *p)
void	Gia_ManCleanPhase (Gia_Man_t *p)
int	Gia_ManCheckCoPhase (Gia_Man_t *p)
void	Gia_ManCleanLevels (Gia_Man_t *p, int Size)
void	Gia_ManCleanTruth (Gia_Man_t *p)
int	Gia_ManLevelNum (Gia_Man_t *p)
int	Gia_ManLevelRNum (Gia_Man_t *p)
float	Gia_ManLevelAve (Gia_Man_t *p)
Vec_Int_t *	Gia_ManGetCiLevels (Gia_Man_t *p)
int	Gia_ManSetLevels (Gia_Man_t *p, Vec_Int_t *vCiLevels)
Vec_Int_t *	Gia_ManReverseLevel (Gia_Man_t *p)
Vec_Int_t *	Gia_ManRequiredLevel (Gia_Man_t *p)
Vec_Int_t *	Gia_ManComputeSlacks (Gia_Man_t *p)
void	Gia_ManCreateValueRefs (Gia_Man_t *p)
void	Gia_ManCreateRefs (Gia_Man_t *p)
void	Gia_ManCreateLitRefs (Gia_Man_t *p)
int *	Gia_ManCreateMuxRefs (Gia_Man_t *p)
Vec_Int_t *	Gia_ManBfsForCrossCut (Gia_Man_t *p)
void	Gia_ManDfsForCrossCut_rec (Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vNodes)
Vec_Int_t *	Gia_ManDfsForCrossCut (Gia_Man_t *p, int fReverse)
int	Gia_ManCrossCut (Gia_Man_t *p, int fReverse)
Vec_Int_t *	Gia_ManCollectPoIds (Gia_Man_t *p)
int	Gia_ObjIsMuxType (Gia_Obj_t *pNode)
int	Gia_ObjRecognizeExor (Gia_Obj_t *pObj, Gia_Obj_t **ppFan0, Gia_Obj_t **ppFan1)
Gia_Obj_t *	Gia_ObjRecognizeMux (Gia_Obj_t *pNode, Gia_Obj_t **ppNodeT, Gia_Obj_t **ppNodeE)
int	Gia_ObjRecognizeMuxLits (Gia_Man_t *p, Gia_Obj_t *pNode, int *iLitT, int *iLitE)
int	Gia_NodeDeref_rec (Gia_Man_t *p, Gia_Obj_t *pNode)
int	Gia_NodeRef_rec (Gia_Man_t *p, Gia_Obj_t *pNode, int fMark)
int	Gia_ManPoMffcSize (Gia_Man_t *p)
int	Gia_NodeMffcSize (Gia_Man_t *p, Gia_Obj_t *pNode)
int	Gia_NodeMffcSizeMark (Gia_Man_t *p, Gia_Obj_t *pNode)
void	Gia_NodeCollect_rec (Gia_Man_t *p, Gia_Obj_t *pNode, Vec_Int_t *vSupp)
int	Gia_NodeMffcSizeSupp (Gia_Man_t *p, Gia_Obj_t *pNode, Vec_Int_t *vSupp)
int	Gia_NodeMffcMapping_rec (Gia_Man_t *p, int iObj, Vec_Int_t *vMapping, Vec_Int_t *vSupp)
int	Gia_NodeMffcMapping (Gia_Man_t *p)
int	Gia_ManHasDangling (Gia_Man_t *p)
int	Gia_ManMarkDangling (Gia_Man_t *p)
Vec_Int_t *	Gia_ManGetDangling (Gia_Man_t *p)
void	Gia_ObjPrint (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ManPrint (Gia_Man_t *p)
void	Gia_ManPrintCo_rec (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ManPrintCo (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ManPrintCollect_rec (Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vNodes)
void	Gia_ManPrintCone (Gia_Man_t *p, Gia_Obj_t *pObj, int *pLeaves, int nLeaves, Vec_Int_t *vNodes)
void	Gia_ManPrintConeMulti (Gia_Man_t *p, Vec_Int_t *vObjs, Vec_Int_t *vLeaves, Vec_Int_t *vNodes)
void	Gia_ManPrintCollect2_rec (Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vNodes)
void	Gia_ManPrintCone2 (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ManInvertConstraints (Gia_Man_t *pAig)
void	Gia_ManInvertPos (Gia_Man_t *pAig)
void	Gia_ManCollectObjs_rec (Gia_Man_t *p, int iObjId, Vec_Int_t *vObjs, int Limit)
unsigned *	Gia_ManComputePoTruthTables (Gia_Man_t *p, int nBytesMax)
int	Gia_ManCompare (Gia_Man_t *p1, Gia_Man_t *p2)
void	Gia_ManMarkFanoutDrivers (Gia_Man_t *p)
void	Gia_ManSwapPos (Gia_Man_t *p, int i)
Vec_Int_t *	Gia_ManSaveValue (Gia_Man_t *p)
void	Gia_ManLoadValue (Gia_Man_t *p, Vec_Int_t *vValues)
Vec_Int_t *	Gia_ManFirstFanouts (Gia_Man_t *p)
int	Gia_ManHasChoices_very_old (Gia_Man_t *p)
Vec_Int_t *	Gia_ManGroupProve (Gia_Man_t *pInit, char *pCommLine, int nGroupSize, int fVerbose)
Vec_Int_t *	Gia_ManPoXSim (Gia_Man_t *p, int nFrames, int fVerbose)
void	Gia_AigerWriteLut (Gia_Man_t *p, char *pFileName)
void	Gia_DumpLutSizeDistrib (Gia_Man_t *p, char *pFileName)
void	Gia_ManCheckSuppMark_rec (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ManCheckSuppUnmark_rec (Gia_Man_t *p, Gia_Obj_t *pObj)
int	Gia_ManCheckSupp_rec (Gia_Man_t *p, Gia_Obj_t *pObj)
int	Gia_ManCheckSuppOverlap (Gia_Man_t *p, int iNode1, int iNode2)
int	Gia_ManCountPisWithFanout (Gia_Man_t *p)
int	Gia_ManCountPosWithNonZeroDrivers (Gia_Man_t *p)
void	Gia_ManUpdateCopy (Vec_Int_t *vCopy, Gia_Man_t *p)
Gia_Man_t *	Gia_ManDupWithMuxPos (Gia_Man_t *p)
void	Gia_ManRingAdd (Gia_Man_t *p, int iObj, Vec_Int_t *vRes, Vec_Int_t *vDists, int Dist)
void	Gia_ManCollectRing (Gia_Man_t *p, Vec_Int_t *vStart, Vec_Int_t *vRes, Vec_Int_t *vDists)
Vec_Int_t *	Gia_ManComputeDistanceInt (Gia_Man_t *p, int iTarg, Vec_Int_t *vObjs, int fVerbose)
Vec_Int_t *	Gia_ManComputeDistance (Gia_Man_t *p, int iObj, Vec_Int_t *vObjs, int fVerbose)
void	Gia_ComputeTest ()
int	Gia_ManSumTotalOfSupportSizes (Gia_Man_t *p)
int	Gia_ManSumTotalOfSupportSizes2 (Gia_Man_t *p)
Gia_Man_t *	Gia_ManComputeCofs (Gia_Man_t *p, int nVars)
Gia_Man_t *	Gia_ManComputeCofs2 (Gia_Man_t *p)
Gia_Man_t *	Gia_ManComputeDepAig (Gia_Man_t *p, int iIn, int iOut)
int	Gia_ManComputeDep (Gia_Man_t *p, int iIn, int iOut)
Gia_Man_t *	Gia_ManComputeDepTest (Gia_Man_t *p)
Vec_Wec_t *	Gia_ManComputeSupports (Gia_Man_t *p)
Vec_Wec_t *	Gia_ManComputeSharing (Vec_Wec_t *vSupps)
Vec_Str_t *	Gia_ManConvertDump (Gia_Man_t *p, Vec_Wec_t *vSupps)
void	Gia_ManDumpSuppFile (Vec_Str_t *p, char *pFileName)
void	Gia_ManDumpSuppFileTest3 (Gia_Man_t *p, char *pFileName)
void	Gia_ManDumpSuppFileTest (Gia_Man_t *p, char *pFileName)
void	Gia_ManConvertSupp_rec (Gia_Man_t *pNew, Gia_Man_t *p, Gia_Obj_t *pObj)
Gia_Man_t *	Gia_ManConvertSupp (Gia_Man_t *p)
Gia_Man_t *	Gia_ManTransformCond2 (Gia_Man_t *p)
Vec_Wrd_t *	Gia_ManDetectSims (Gia_Man_t *p, int iCo, int nWords)
Vec_Wrd_t *	Vec_WrdInterleave (Vec_Wrd_t *p1, Vec_Wrd_t *p2, int nWords, int nIns)
Gia_Man_t *	Gia_ManTransformCond (Gia_Man_t *p)
void	Gia_ManWriteSol (Gia_Man_t *p, char *pFileName)
void	Gia_ManWriteResub (Gia_Man_t *p, char *pFileName)
void	Gia_ManPrintArray (Gia_Man_t *p)
int	Gia_GetMValue (int i, int nIns, int Mint, unsigned Truth)
void	Gia_ManTestProblem ()
int	Gia_ManWindowCheckTopoError_rec (Gia_Man_t *p, Gia_Obj_t *pObj)
int	Gia_ManWindowCheckTopoError (Gia_Man_t *p, Vec_Int_t *vIns, Vec_Int_t *vOuts)
int	Gia_ManDupInsertWindows_rec (Gia_Man_t *pNew, Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vMap, Vec_Ptr_t *vvIns, Vec_Ptr_t *vvOuts, Vec_Ptr_t *vWins)
Gia_Man_t *	Gia_ManDupInsertWindows (Gia_Man_t *p, Vec_Ptr_t *vvIns, Vec_Ptr_t *vvOuts, Vec_Ptr_t *vWins)
Gia_Man_t *	Gia_ManCreateDualOutputMiter (Gia_Man_t *p0, Gia_Man_t *p1)
Vec_Int_t *	Gia_ManFindMutualEquivs (Gia_Man_t *p0, Gia_Man_t *p1, int nConflictLimit, int fVerbose)
void	Gia_ManFindMutualEquivsTest ()

Macro Definition Documentation

MAX_LUT_SIZE

#define MAX_LUT_SIZE   8

Definition at line 2118 of file giaUtil.c.

NUMBER1

#define NUMBER1   3716960521u

DECLARATIONS ///.

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

FileName [giaUtil.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Various utilities.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 31 of file giaUtil.c.

NUMBER2

#define NUMBER2   2174103536u

Definition at line 32 of file giaUtil.c.

Typedef Documentation

Gia_MapLut_t

typedef struct Gia_MapLut_t_ Gia_MapLut_t

Function Documentation

Gia_AigerWriteLut()

void Gia_AigerWriteLut	(	Gia_Man_t *	p,
		char *	pFileName )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2141 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, k, iFan, iLut = 0;
    int LutSizeMax = Gia_ManLutSizeMax( p );
    int nUints = Abc_TruthWordNum(LutSizeMax);
    int nLuts = 1 + Gia_ManCiNum(p) + Gia_ManCoNum(p) + Gia_ManLutNum(p);
    Gia_MapLut_t * pLuts = ABC_CALLOC( Gia_MapLut_t, nLuts );
    Vec_Wrd_t * vTruths = Vec_WrdStart( Gia_ManObjNum(p) );
    assert( LutSizeMax <= 6 );
    // set obj numbers
    // constant
    pLuts->Type = 3;
    memset( pLuts->pTruth, 0xFF, sizeof(unsigned) * nUints );
    Gia_ManFillValue(p);
    Gia_ManConst0(p)->Value = pLuts[iLut].Out = Abc_Var2Lit( iLut, 0 );
    iLut++;
    // inputs
    Gia_ManForEachCi( p, pObj, i )
    {
        pLuts[iLut].Type = 1;
        memset( pLuts[iLut].pTruth, 0xAA, sizeof(unsigned) * nUints );
        pObj->Value = pLuts[iLut].Out = Abc_Var2Lit( iLut, 0 );
        iLut++;
    }
    // nodes
    Gia_ManForEachObj( p, pObj, i )
        if ( i && Gia_ObjIsLut(p, i) )
        {
            word truth;
            pLuts[iLut].Type = 3;
            Gia_LutForEachFanin( p, i, iFan, k )
                pLuts[iLut].pFans[k] = Gia_ManObj(p, iFan)->Value;
            pLuts[iLut].nFans = k;
            truth = Gia_LutComputeTruth6(p, i, vTruths);
            memcpy( pLuts[iLut].pTruth, &truth, sizeof(word) );
            pObj->Value = pLuts[iLut].Out = Abc_Var2Lit( iLut, 0 );
            iLut++;
        }
    // outputs
    Gia_ManForEachCo( p, pObj, i )
    {
        pLuts[iLut].Type = 2;
        pLuts[iLut].pFans[0] = Gia_ObjFanin0(pObj)->Value;
        if ( Gia_ObjFaninC0(pObj) ^ Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) )
            memset( pLuts[iLut].pTruth, 0x55, sizeof(unsigned) * nUints );
        else
            memset( pLuts[iLut].pTruth, 0xAA, sizeof(unsigned) * nUints );
        pLuts[iLut].nFans = 1;
        pObj->Value = pLuts[iLut].Out = Abc_Var2Lit( iLut, 0 );
        iLut++;
    }
    assert( iLut == nLuts );
    // dump into a file
    {
        FILE * pFile = fopen( pFileName, "wb" );
        if ( pFile == NULL )
            printf( "Cannot open file \"%s\" for writing.\n", pFileName );
        else
        {
            int nSize1 = nLuts * sizeof(Gia_MapLut_t);
            int nSize2 = fwrite( pLuts, 1, nSize1, pFile );
            assert( nSize1 == nSize2 );
            printf( "Successfully dumped %d bytes of binary data.\n", nSize1 );
        }
        fclose( pFile );
    }
    ABC_FREE( pLuts );
    Vec_WrdFree( vTruths );
}

Here is the call graph for this function:

Gia_ComputeTest()

void Gia_ComputeTest

(

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2534 of file giaUtil.c.

{
    char * pStart, Line [1000]; float Total = 0;
    char * pFileName = "data.txt";
    FILE * pFile = fopen( pFileName, "r" );
    if ( pFile == NULL )
        { printf( "Input file \"%s\" cannot be opened.\n", pFileName ); return; }
    while ( fgets( Line, 1000, pFile ) != NULL )
    {
        if ( !strstr(Line, "xxx") )
            continue;
        if ( !strstr(Line, "yyy") )
            continue;
        //printf( "%s", Line );
        pStart = strstr(Line, "zzz");
        if ( pStart == NULL )
            continue;
        //printf( "%s", pStart + 4 );
        Total += -atof( pStart + 4 );
    }
    printf( "Total = %.2f\n", Total );
    fclose( pFile );
}

Here is the call graph for this function:

Gia_DumpLutSizeDistrib()

void Gia_DumpLutSizeDistrib	(	Gia_Man_t *	p,
		char *	pFileName )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2223 of file giaUtil.c.

{
    FILE * pTable = fopen( pFileName, "a+" );
    int i, Counts[10] = {0};
    Gia_ManForEachLut( p, i )
        if ( Gia_ObjLutSize(p, i) > 0 && Gia_ObjLutSize(p, i) < 10 )
            Counts[ Gia_ObjLutSize(p, i) ]++;
    fprintf( pTable, "%s", p->pName );
    for ( i = 1; i < 10; i++ )
        fprintf( pTable, " %d", Counts[i] );
    fprintf( pTable, "\n" );
    fclose( pTable );
}

Gia_FileNameGenericAppend()

char * Gia_FileNameGenericAppend	(	char *	pBase,
		char *	pSuffix )

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

Synopsis [Returns the composite name of the file.]

Description []

SideEffects []

SeeAlso []

Definition at line 130 of file giaUtil.c.

{
    static char Buffer[1000];
    char * pDot;
    strcpy( Buffer, pBase );
    if ( (pDot = strrchr( Buffer, '.' )) )
        *pDot = 0;
    strcat( Buffer, pSuffix );
    if ( (pDot = strrchr( Buffer, '\\' )) || (pDot = strrchr( Buffer, '/' )) )
        return pDot+1;
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_GetFakeNames()

Vec_Ptr_t * Gia_GetFakeNames	(	int	nNames,
		int	fCaps )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 154 of file giaUtil.c.

{
    Vec_Ptr_t * vNames;
    char Buffer[5];
    int i;
 
    vNames = Vec_PtrAlloc( nNames );
    for ( i = 0; i < nNames; i++ )
    {
        if ( nNames < 26 )
        {
            Buffer[0] = (fCaps ? 'A' : 'a') + i;
            Buffer[1] = 0;
        }
        else
        {
            Buffer[0] = (fCaps ? 'A' : 'a') + i%26;
            Buffer[1] = '0' + i/26;
            Buffer[2] = 0;
        }
        Vec_PtrPush( vNames, Extra_UtilStrsav(Buffer) );
    }
    return vNames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_GetMValue()

int Gia_GetMValue	(	int	i,
		int	nIns,
		int	Mint,
		unsigned	Truth )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 3235 of file giaUtil.c.

{
    assert( i >= 0 && i < 16 );
    if ( i < nIns )
        return (Mint >> i) & 1;
    if ( i == nIns )
    {
        if ( Mint < (1 << nIns) )
            return (Truth >> Mint) & 1;
        else 
            return ((Truth >> (Mint-(1 << nIns))) & 1) == 0;
    }
    else
        return 1;
}

Here is the caller graph for this function:

Gia_ManBfsForCrossCut()

Vec_Int_t * Gia_ManBfsForCrossCut

(

Gia_Man_t *

p

)

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

Synopsis [Computes the maximum frontier size.]

Description []

SideEffects []

SeeAlso []

Definition at line 856 of file giaUtil.c.

{
    Vec_Int_t * vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
    Vec_Vec_t * vLevels = Gia_ManLevelize( p );
    Vec_Ptr_t * vObjs;
    Gia_Obj_t * pObj;
    int i, k;
    Vec_VecForEachLevel( vLevels, vObjs, i )
        Vec_PtrForEachEntry( Gia_Obj_t *, vObjs, pObj, k )
            Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
    Vec_VecFree( vLevels );
    return vNodes;
}

Here is the call graph for this function:

Gia_ManCheckCoPhase()

int Gia_ManCheckCoPhase

(

Gia_Man_t *

p

)

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

Synopsis [Returns the number of COs whose value is 1.]

Description []

SideEffects []

SeeAlso []

Definition at line 491 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0;
    Gia_ManForEachCo( p, pObj, i )
        Counter += pObj->fPhase;
    return Counter;
}

Here is the caller graph for this function:

Gia_ManCheckMark0()

void Gia_ManCheckMark0

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 275 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        assert( pObj->fMark0 == 0 );
}

Gia_ManCheckMark1()

void Gia_ManCheckMark1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 332 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        assert( pObj->fMark1 == 0 );
}

Here is the caller graph for this function:

Gia_ManCheckSupp_rec()

int Gia_ManCheckSupp_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

Definition at line 2268 of file giaUtil.c.

{
    if ( pObj->fMark0 )
        return 1;
    if ( Gia_ObjIsCi(pObj) )
        return 0;
    if ( Gia_ManCheckSupp_rec( p, Gia_ObjFanin0(pObj) ) )
        return 1;
    return Gia_ManCheckSupp_rec( p, Gia_ObjFanin1(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCheckSuppMark_rec()

void Gia_ManCheckSuppMark_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

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

Synopsis [Check if two logic cones have overlap.]

Description []

SideEffects []

SeeAlso []

Definition at line 2248 of file giaUtil.c.

{
    if ( pObj->fMark0 )
        return;
    pObj->fMark0 = 1;
    if ( Gia_ObjIsCi(pObj) )
        return;
    Gia_ManCheckSuppMark_rec( p, Gia_ObjFanin0(pObj) );
    Gia_ManCheckSuppMark_rec( p, Gia_ObjFanin1(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCheckSuppOverlap()

int Gia_ManCheckSuppOverlap	(	Gia_Man_t *	p,
		int	iNode1,
		int	iNode2 )

Definition at line 2278 of file giaUtil.c.

{
    int Result;
    if ( iNode1 == 0 || iNode2 == 0 )
        return 0;
    Gia_ManCheckSuppMark_rec( p, Gia_ManObj(p, iNode1) );
    Result = Gia_ManCheckSupp_rec( p, Gia_ManObj(p, iNode2) );
    Gia_ManCheckSuppUnmark_rec( p, Gia_ManObj(p, iNode1) );
    return Result;
}

Here is the call graph for this function:

Gia_ManCheckSuppUnmark_rec()

void Gia_ManCheckSuppUnmark_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

Definition at line 2258 of file giaUtil.c.

{
    if ( !pObj->fMark0 )
        return;
    pObj->fMark0 = 0;
    if ( Gia_ObjIsCi(pObj) )
        return;
    Gia_ManCheckSuppUnmark_rec( p, Gia_ObjFanin0(pObj) );
    Gia_ManCheckSuppUnmark_rec( p, Gia_ObjFanin1(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCleanLevels()

void Gia_ManCleanLevels	(	Gia_Man_t *	p,
		int	Size )

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

Synopsis [Prepares copies for the model.]

Description []

SideEffects []

SeeAlso []

Definition at line 511 of file giaUtil.c.

{
    if ( p->vLevels == NULL )
        p->vLevels = Vec_IntAlloc( Size );
    Vec_IntFill( p->vLevels, Size, 0 );
}

Here is the caller graph for this function:

Gia_ManCleanMark0()

void Gia_ManCleanMark0

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 256 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark0 = 0;
}

Gia_ManCleanMark01()

void Gia_ManCleanMark01

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 218 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark0 = pObj->fMark1 = 0;
}

Here is the caller graph for this function:

Gia_ManCleanMark1()

void Gia_ManCleanMark1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 313 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark1 = 0;
}

Here is the caller graph for this function:

Gia_ManCleanPhase()

void Gia_ManCleanPhase

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 472 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fPhase = 0;
}

Here is the caller graph for this function:

Gia_ManCleanTruth()

void Gia_ManCleanTruth

(

Gia_Man_t *

p

)

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

Synopsis [Prepares copies for the model.]

Description []

SideEffects []

SeeAlso []

Definition at line 528 of file giaUtil.c.

{
    if ( p->vTruths == NULL )
        p->vTruths = Vec_IntAlloc( Gia_ManObjNum(p) );
    Vec_IntFill( p->vTruths, Gia_ManObjNum(p), -1 );
}

Here is the caller graph for this function:

Gia_ManCleanValue()

void Gia_ManCleanValue

(

Gia_Man_t *

p

)

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

Synopsis [Cleans the value.]

Description []

SideEffects []

SeeAlso []

Definition at line 351 of file giaUtil.c.

{
    int i;
    for ( i = 0; i < p->nObjs; i++ )
        p->pObjs[i].Value = 0;
}

Here is the caller graph for this function:

Gia_ManCollectObjs_rec()

void Gia_ManCollectObjs_rec	(	Gia_Man_t *	p,
		int	iObjId,
		Vec_Int_t *	vObjs,
		int	Limit )

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

Synopsis [Testing the speedup due to grouping POs into batches.]

Description []

SideEffects []

SeeAlso []

Definition at line 1670 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    if ( Vec_IntSize(vObjs) == Limit )
        return;
    if ( Gia_ObjIsTravIdCurrentId(p, iObjId) )
        return;
    Gia_ObjSetTravIdCurrentId(p, iObjId);
    pObj = Gia_ManObj( p, iObjId );
    if ( Gia_ObjIsAnd(pObj) )
    {
        Gia_ManCollectObjs_rec( p, Gia_ObjFaninId0p(p, pObj), vObjs, Limit );
        if ( Vec_IntSize(vObjs) == Limit )
            return;
        Gia_ManCollectObjs_rec( p, Gia_ObjFaninId1p(p, pObj), vObjs, Limit );
        if ( Vec_IntSize(vObjs) == Limit )
            return;
    }
    Vec_IntPush( vObjs, iObjId );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCollectPoIds()

Vec_Int_t * Gia_ManCollectPoIds

(

Gia_Man_t *

p

)

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

Synopsis [Collects PO Ids into one array.]

Description []

SideEffects []

SeeAlso []

Definition at line 960 of file giaUtil.c.

{
    Vec_Int_t * vStart;
    int Entry, i;
    vStart = Vec_IntAlloc( Gia_ManPoNum(p) );
    Vec_IntForEachEntryStop( p->vCos, Entry, i, Gia_ManPoNum(p) )
        Vec_IntPush( vStart, Entry );
    return vStart;
}

Here is the caller graph for this function:

Gia_ManCollectRing()

void Gia_ManCollectRing	(	Gia_Man_t *	p,
		Vec_Int_t *	vStart,
		Vec_Int_t *	vRes,
		Vec_Int_t *	vDists )

Definition at line 2454 of file giaUtil.c.

{
    int i, k, iObj, iFan;
    Vec_IntForEachEntry( vStart, iObj, i )
    {
        int Weight = Vec_IntEntry( vDists, iObj );
        Gia_Obj_t * pObj = Gia_ManObj(p, iObj);
        assert( Weight > 0 );
        if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ManRingAdd( p, Gia_ObjFaninId0(pObj, iObj), vRes, vDists, Weight + 1*!Gia_ObjIsBuf(Gia_ObjFanin0(pObj)) );
            Gia_ManRingAdd( p, Gia_ObjFaninId1(pObj, iObj), vRes, vDists, Weight + 1*!Gia_ObjIsBuf(Gia_ObjFanin1(pObj)) );
        }
        Gia_ObjForEachFanoutStaticId( p, iObj, iFan, k )
            Gia_ManRingAdd( p, iFan, vRes, vDists, Weight + 1*!Gia_ObjIsBuf(Gia_ManObj(p, iFan)) );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCompare()

int Gia_ManCompare	(	Gia_Man_t *	p1,
		Gia_Man_t *	p2 )

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

Synopsis [Returns 1 if the manager are structural identical.]

Description []

SideEffects []

SeeAlso []

Definition at line 1737 of file giaUtil.c.

{
    Gia_Obj_t * pObj1, * pObj2;
    int i;
    if ( Gia_ManObjNum(p1) != Gia_ManObjNum(p2) )
    {
        printf( "AIGs have different number of objects.\n" );
        return 0;
    }
    Gia_ManCleanValue( p1 );
    Gia_ManCleanValue( p2 );
    Gia_ManForEachObj( p1, pObj1, i )
    {
        pObj2 = Gia_ManObj( p2, i );
        if ( memcmp( pObj1, pObj2, sizeof(Gia_Obj_t) ) )
        {
            printf( "Objects %d are different.\n", i );
            return 0;
        }
        if ( p1->pReprs && p2->pReprs )
        {
            if ( memcmp( &p1->pReprs[i], &p2->pReprs[i], sizeof(Gia_Rpr_t) ) )
            {
                printf( "Representatives of objects %d are different.\n", i );
                return 0;
            }
        }
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManComputeCofs()

Gia_Man_t * Gia_ManComputeCofs	(	Gia_Man_t *	p,
		int	nVars )

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

Synopsis [Compute dependency.]

Description []

SideEffects []

SeeAlso []

Definition at line 2628 of file giaUtil.c.

{
    Gia_Man_t * pNew, * pTemp; 
    Gia_Obj_t * pObj; int i, m;
    Gia_Obj_t * pSink  = Gia_ManCo(p, 0);
    Vec_Int_t * vRoots = Vec_IntAlloc( 1 );
    Vec_Int_t * vNodes = Vec_IntAlloc( 1000 );
    Vec_IntPush( vRoots, Gia_ObjFaninId0p(p, pSink) );
    Gia_ManCollectTfi( p, vRoots, vNodes );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManHashAlloc( pNew );
    for ( m = 0; m < (1 << nVars); m++ )
    {
        for ( i = 0; i < nVars; i++ )
            Gia_ManCi(p, Gia_ManCiNum(p)-nVars+i)->Value = (m >> i) & 1;
        Gia_ManForEachObjVec( vNodes, p, pObj, i )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pSink) );
    }
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Vec_IntFree( vRoots );
    Vec_IntFree( vNodes );
    return pNew;
}

Here is the call graph for this function:

Gia_ManComputeCofs2()

Gia_Man_t * Gia_ManComputeCofs2

(

Gia_Man_t *

p

)

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

Synopsis [Compute dependency.]

Description []

SideEffects []

SeeAlso []

Definition at line 2668 of file giaUtil.c.

{
    Gia_Man_t * pNew, * pTemp; 
    Gia_Obj_t * pObj, * pSink; int i, o, m;
    Vec_Int_t * vSupp = Vec_IntAlloc( 1000 );
    Vec_Int_t * vAnds = Vec_IntAlloc( 1000 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManForEachCi( p, pObj, i )
    {
        pObj->Value = Gia_ManAppendCi(pNew);
        assert( (int)pObj->Value == Abc_Var2Lit( 1 + Gia_ObjCioId(pObj), 0 ) );
    }
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachRi( p, pSink, o )
    {
        int Fanin = Gia_ObjFaninId0p( p, pSink );
        Vec_Int_t * vNodes = Gia_ManCollectNodesCis( p, &Fanin, 1 );
        Vec_IntClear( vSupp );
        Vec_IntClear( vAnds );
        Gia_ManForEachObjVec( vNodes, p, pObj, i )
            Vec_IntPush( Gia_ObjIsAnd(pObj) ? vAnds : vSupp, Gia_ObjId(p, pObj) );
        Vec_IntFree( vNodes );
        Vec_IntSort( vSupp, 0 );
        for ( m = 0; m < 5; m++ )
        {
            Gia_ManForEachObjVec( vSupp, p, pObj, i )
                if ( i >= Vec_IntSize(vSupp)-5 )
                    pObj->Value = (i == Vec_IntSize(vSupp)-5+m) ? 1 : 0;
            Gia_ManForEachObjVec( vAnds, p, pObj, i )
                pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
            //if ( m == 4 )
            //    Gia_ManAppendCo( pNew, 0 );   
            //else
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pSink) );
            Gia_ManAppendCo( pNew, Abc_Var2Lit( Vec_IntEntry(vSupp, Vec_IntSize(vSupp)-5+m), 0 ) );
            Gia_ManForEachObjVec( vSupp, p, pObj, i )
                if ( i >= Vec_IntSize(vSupp)-5 )
                    pObj->Value = Abc_Var2Lit( 1 + Gia_ObjCioId(pObj), 0 );
        }
    }
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Vec_IntFree( vSupp );
    Vec_IntFree( vAnds );
    return pNew;
}

Here is the call graph for this function:

Gia_ManComputeDep()

int Gia_ManComputeDep	(	Gia_Man_t *	p,
		int	iIn,
		int	iOut )

Definition at line 2757 of file giaUtil.c.

{
    extern Gia_Man_t * Cec4_ManSimulateTest3( Gia_Man_t * p, int nBTLimit, int fVerbose );
    Gia_Man_t * pNew = Gia_ManComputeDepAig( p, iIn, iOut );
    Gia_Man_t * pSwp = Cec4_ManSimulateTest3( pNew, 100000, 0 );
    int iLit[2] = { Gia_ObjFaninId0p( pSwp, Gia_ManCo(pSwp, 0) ), Gia_ObjFaninId0p( pSwp, Gia_ManCo(pSwp, 1) ) };
    Gia_ManStop( pNew );
    Gia_ManStop( pSwp );
    if ( iLit[0] == 0 && iLit[1] == 0 )
        return 2;
    if ( iLit[1] == 0 )
        return 1;
    if ( iLit[0] == 0 )
        return 0;
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManComputeDepAig()

Gia_Man_t * Gia_ManComputeDepAig	(	Gia_Man_t *	p,
		int	iIn,
		int	iOut )

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

Synopsis [Compute dependency.]

Description []

SideEffects []

SeeAlso []

Definition at line 2727 of file giaUtil.c.

{
    Gia_Man_t * pNew, * pTemp; 
    Gia_Obj_t * pObj; int i, n, iLits[2];
    Gia_Obj_t * pPivot = Gia_ManCi(p, iIn);
    Gia_Obj_t * pSink  = Gia_ManCo(p, iOut);
    Vec_Int_t * vRoots = Vec_IntAlloc( 1 );
    Vec_Int_t * vNodes = Vec_IntAlloc( 1000 );
    Vec_IntPush( vRoots, Gia_ObjFaninId0p(p, pSink) );
    Gia_ManCollectTfi( p, vRoots, vNodes );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManHashAlloc( pNew );
    for ( n = 0; n < 2; n++ )
    {
        pPivot->Value = n;
        Gia_ManForEachObjVec( vNodes, p, pObj, i )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        iLits[n] = Gia_ObjFanin0Copy(pSink);
    }
    Gia_ManAppendCo( pNew, Gia_ManHashAnd(pNew, iLits[1], Abc_LitNot(iLits[0])) );
    Gia_ManAppendCo( pNew, Gia_ManHashAnd(pNew, iLits[0], Abc_LitNot(iLits[1])) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Vec_IntFree( vRoots );
    Vec_IntFree( vNodes );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManComputeDepTest()

Gia_Man_t * Gia_ManComputeDepTest

(

Gia_Man_t *

p

)

Definition at line 2773 of file giaUtil.c.

{
    abctime clk = Abc_Clock();
    int i;
    for ( i = 0; i < Gia_ManCiNum(p); i++ )
        printf( "%3d : %3d\n", i, Gia_ManComputeDep(p, i, 0) );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    return Gia_ManDup(p);
}

Here is the call graph for this function:

Gia_ManComputeDistance()

Vec_Int_t * Gia_ManComputeDistance	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vObjs,
		int	fVerbose )

Definition at line 2508 of file giaUtil.c.

{
    Vec_Int_t * vDists;
    if ( p->vFanoutNums )
        vDists = Gia_ManComputeDistanceInt( p, iObj, vObjs, fVerbose );
    else
    {
        Gia_ManStaticFanoutStart( p );
        vDists = Gia_ManComputeDistanceInt( p, iObj, vObjs, fVerbose );
        Gia_ManStaticFanoutStop( p );
    }
    return vDists;
}

Here is the call graph for this function:

Gia_ManComputeDistanceInt()

Vec_Int_t * Gia_ManComputeDistanceInt	(	Gia_Man_t *	p,
		int	iTarg,
		Vec_Int_t *	vObjs,
		int	fVerbose )

Definition at line 2471 of file giaUtil.c.

{
    int i, iObj;
    Vec_Int_t * vDists, * vStart, * vNexts;
    vStart = Vec_IntAlloc( 100 );
    vNexts = Vec_IntAlloc( 100 );
    vDists = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_ManIncrementTravId( p );
    if ( vObjs )
    {
        Vec_IntForEachEntry( vObjs, iObj, i )
        {
            Gia_ObjSetTravIdCurrentId(p, iObj);
            Vec_IntWriteEntry( vDists, iObj, 1 );
            Vec_IntPush( vStart, iObj );
        }
    }
    else
    {
        Gia_ObjSetTravIdCurrentId(p, iTarg);
        Vec_IntWriteEntry( vDists, iTarg, 1 );
        Vec_IntPush( vStart, iTarg );
    }
    for ( i = 0; ; i++ )
    {
        if ( fVerbose )
            printf( "Ring %2d : %6d\n", i, Vec_IntSize(vDists)-Vec_IntCountZero(vDists) );        
        Gia_ManCollectRing( p, vStart, vNexts, vDists );
        if ( Vec_IntSize(vNexts) == 0 )
            break;
        Vec_IntClear( vStart );
        ABC_SWAP( Vec_Int_t, *vStart, *vNexts );
    }
    Vec_IntFree( vStart );
    Vec_IntFree( vNexts );
    return vDists;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManComputePoTruthTables()

unsigned * Gia_ManComputePoTruthTables	(	Gia_Man_t *	p,
		int	nBytesMax )

Definition at line 1690 of file giaUtil.c.

{
    int nVars = Gia_ManPiNum(p);
    int nTruthWords = Abc_TruthWordNum( nVars );
    int nTruths = nBytesMax / (sizeof(unsigned) * nTruthWords);
    int nTotalNodes = 0, nRounds = 0;
    Vec_Int_t * vObjs;
    Gia_Obj_t * pObj;
    abctime clk = Abc_Clock();
    int i;
    printf( "Var = %d. Words = %d. Truths = %d.\n", nVars, nTruthWords, nTruths );
    vObjs = Vec_IntAlloc( nTruths );
    Gia_ManIncrementTravId( p );
    Gia_ManForEachPo( p, pObj, i )
    {
        Gia_ManCollectObjs_rec( p, Gia_ObjFaninId0p(p, pObj), vObjs, nTruths );
        if ( Vec_IntSize(vObjs) == nTruths )
        {
            nRounds++;
//            printf( "%d ", i );
            nTotalNodes += Vec_IntSize( vObjs );
            Vec_IntClear( vObjs );
            Gia_ManIncrementTravId( p );
        }
    }
//    printf( "\n" );
    nTotalNodes += Vec_IntSize( vObjs );
    Vec_IntFree( vObjs );
 
    printf( "Rounds = %d. Objects = %d. Total = %d.   ", nRounds, Gia_ManObjNum(p), nTotalNodes );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
 
    return NULL;
}

Here is the call graph for this function:

Gia_ManComputeSharing()

Vec_Wec_t * Gia_ManComputeSharing

(

Vec_Wec_t *

vSupps

)

Definition at line 2808 of file giaUtil.c.

{   
    Vec_Wec_t * vDiffs = Vec_WecStart( Vec_WecSize(vSupps) );
    Vec_Int_t * vNew, * vOld; int i;
    Vec_WecForEachLevelTwo( vDiffs, vSupps, vNew, vOld, i ) if ( i )
        Vec_IntTwoFindCommon( Vec_WecEntry(vSupps, i-1), vOld, vNew ); 
    return vDiffs;
}

Here is the caller graph for this function:

Gia_ManComputeSlacks()

Vec_Int_t * Gia_ManComputeSlacks

(

Gia_Man_t *

p

)

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

Synopsis [Compute slacks measured using the number of AIG levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 726 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, nLevels = Gia_ManLevelNum( p );
    Vec_Int_t * vLevelR = Gia_ManReverseLevel( p );
    Vec_Int_t * vSlacks = Vec_IntAlloc( Gia_ManObjNum(p) );
    Gia_ManForEachObj( p, pObj, i )
        Vec_IntPush( vSlacks, nLevels - Gia_ObjLevelId(p, i) - Vec_IntEntry(vLevelR, i) );
    assert( Vec_IntSize(vSlacks) == Gia_ManObjNum(p) );
    Vec_IntFree( vLevelR );
    return vSlacks;
}

Here is the call graph for this function:

Gia_ManComputeSupports()

Vec_Wec_t * Gia_ManComputeSupports

(

Gia_Man_t *

p

)

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

Synopsis [Compute support diffs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2794 of file giaUtil.c.

{   
    Vec_Wec_t * vRes = Vec_WecStart( Gia_ManCoNum(p) ); 
    Vec_Wec_t * vSupps = Vec_WecStart( Gia_ManObjNum(p) );
    Gia_Obj_t * pObj; int i;
    for ( i = 0; i < Gia_ManCiNum(p); i++ )
        Vec_IntPush( Vec_WecEntry(vSupps, 1+i), i );
    Gia_ManForEachAnd( p, pObj, i )
        Vec_IntTwoMerge2( Vec_WecEntry(vSupps, Gia_ObjFaninId0(pObj, i)), Vec_WecEntry(vSupps, Gia_ObjFaninId1(pObj, i)), Vec_WecEntry(vSupps, i) ); 
    Gia_ManForEachCo( p, pObj, i )
        Vec_IntAppend( Vec_WecEntry(vRes, i), Vec_WecEntry(vSupps, Gia_ObjFaninId0p(p, pObj)) );
    Vec_WecFree( vSupps );
    return vRes;
}

Here is the caller graph for this function:

Gia_ManConvertDump()

Vec_Str_t * Gia_ManConvertDump	(	Gia_Man_t *	p,
		Vec_Wec_t *	vSupps )

Definition at line 2816 of file giaUtil.c.

{
    int fPrintDep = 1;
    int nSize = Gia_ManCoNum(p) * (Gia_ManCiNum(p) + 1) + 1;
    Vec_Str_t * vRes = Vec_StrAlloc( nSize );
    Vec_Int_t * vLevel; int i, k, Obj;
    assert( Gia_ManCoNum(p) == Vec_WecSize(vSupps) );
    Vec_StrFill( vRes, nSize-1, '_' );
    Vec_StrPush( vRes, '\0' );
    Vec_WecForEachLevel( vSupps, vLevel, i )
    {
        Vec_IntForEachEntry( vLevel, Obj, k )
        {
            if ( !fPrintDep )
                Vec_StrWriteEntry( vRes, i * (Gia_ManCiNum(p) + 1) +  Obj, '*' );
            else
            {
                int Value = Gia_ManComputeDep( p, Obj, i );
                if ( Value == -1 )
                    Vec_StrWriteEntry( vRes, i * (Gia_ManCiNum(p) + 1) +  Obj, '*' );
                else
                    Vec_StrWriteEntry( vRes, i * (Gia_ManCiNum(p) + 1) +  Obj, (char)('0'+Value) );
            }
        }
        Vec_StrWriteEntry( vRes, i * (Gia_ManCiNum(p) + 1) +  Gia_ManCiNum(p), '\n' );
        //printf( "Output %d\n", i );
    }
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManConvertSupp()

Gia_Man_t * Gia_ManConvertSupp

(

Gia_Man_t *

p

)

Definition at line 2905 of file giaUtil.c.

{
    int fOnly1 = 0;
    int fVerbose = 1;
    abctime clk = Abc_Clock();
    Gia_Man_t * pNew, * pTemp; 
    Gia_Obj_t * pObjPi, * pObjRi, * pObjRo; 
    Vec_Int_t * vSupp = Vec_IntAlloc( 100 );
    Vec_Int_t * vAnds = Vec_IntAlloc( 100 );
    int i, n, iLits[2];
    assert( Gia_ManRegNum(p) && Gia_ManRegNum(p) % 8 == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManFillValue(p);
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachPi( p, pObjPi, i )
        pObjPi->Value = Gia_ManAppendCi( pNew );
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachRi( p, pObjRi, i )
    {
        pObjRo = Gia_ObjRiToRo(p, pObjRi);
        if ( (i - Gia_ManPoNum(p)) % 8 != 0 )
            continue;
        if ( fOnly1 )
        {
            assert( pObjRo->Value == ~0 );
            for ( n = 0; n < 2; n++ )
            {
                pObjRo->Value = n;
                Gia_ManIncrementTravId( p );
                Gia_ManConvertSupp_rec( pNew, p, Gia_ObjFanin0(pObjRi) );
                iLits[n] = Gia_ObjFanin0Copy(pObjRi);
            }
            pObjRo->Value = ~0;
            Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ManHashAnd( pNew, iLits[1], Abc_LitNot(iLits[0]) )) );
        }
        else
        {
            int Fanin = Gia_ObjFaninId0p( p, pObjRi );
            Vec_Int_t * vNodes = Gia_ManCollectNodesCis( p, &Fanin, 1 ); 
            Gia_Obj_t * pObj; int i, m;
            Vec_IntClear( vSupp );
            Vec_IntClear( vAnds );
            Gia_ManForEachObjVec( vNodes, p, pObj, i )
                Vec_IntPush( Gia_ObjIsAnd(pObj) ? vAnds : vSupp, Gia_ObjId(p, pObj) );
            Vec_IntFree( vNodes );
            Vec_IntSort( vSupp, 0 );
            for ( m = 0; m < 4; m++ )
            {
                Gia_ManForEachObjVec( vSupp, p, pObj, i )
                    if ( i >= Vec_IntSize(vSupp)-5 )
                        pObj->Value = (i == Vec_IntSize(vSupp)-5+m) ? 1 : 0;
                Gia_ManForEachObjVec( vAnds, p, pObj, i )
                    pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
                //if ( m == 4 )
                //    Gia_ManAppendCo( pNew, 0 );   
                //else
                    Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObjRi) );
                //Gia_ManAppendCo( pNew, Abc_Var2Lit( Vec_IntEntry(vSupp, Vec_IntSize(vSupp)-5+m), 0 ) );
                Gia_ManForEachObjVec( vSupp, p, pObj, i )
                    if ( i >= Vec_IntSize(vSupp)-5 )
                        pObj->Value = Abc_Var2Lit( 1 + Gia_ObjCioId(pObj), 0 );
            }
        }
    }
    Vec_IntFree( vSupp );
    Vec_IntFree( vAnds );
    Gia_ManHashStop( pNew );
    //Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    if ( fVerbose )
        printf( "Transformed %d outputs,  ", Gia_ManPoNum(pNew) );
    if ( fVerbose )
        Abc_PrintTime( 0, "Time", Abc_Clock() - clk );
    return pNew;
}

Here is the call graph for this function:

Gia_ManConvertSupp_rec()

void Gia_ManConvertSupp_rec	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

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

Synopsis [Compute support diffs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2894 of file giaUtil.c.

{
    if ( !Gia_ObjIsAnd(pObj) )
        return;
    if ( Gia_ObjIsTravIdCurrent(p, pObj) )
        return;
    Gia_ObjSetTravIdCurrent(p, pObj);
    Gia_ManConvertSupp_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManConvertSupp_rec( pNew, p, Gia_ObjFanin1(pObj) );
    pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCountPisWithFanout()

int Gia_ManCountPisWithFanout

(

Gia_Man_t *

p

)

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

Synopsis [Count PIs with fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 2301 of file giaUtil.c.

{
    Gia_Obj_t * pObj; 
    int i, Count = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->fMark0 = 0;
    Gia_ManForEachAnd( p, pObj, i )
    {
        Gia_ObjFanin0(pObj)->fMark0 = 1;
        Gia_ObjFanin1(pObj)->fMark0 = 1;
    }
    Gia_ManForEachCo( p, pObj, i )
        Gia_ObjFanin0(pObj)->fMark0 = 1;
    Gia_ManForEachCi( p, pObj, i )
        Count += pObj->fMark0;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark0 = 0;
    return Count;
}

Gia_ManCountPosWithNonZeroDrivers()

int Gia_ManCountPosWithNonZeroDrivers

(

Gia_Man_t *

p

)

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

Synopsis [Count POs driven by non-zero driver.]

Description []

SideEffects []

SeeAlso []

Definition at line 2332 of file giaUtil.c.

{
    Gia_Obj_t * pObj; 
    int i, Count = 0;
    Gia_ManForEachCo( p, pObj, i )
        Count += Gia_ObjFaninLit0(pObj, Gia_ObjId(p, pObj)) != 0;
    return Count;
}

Gia_ManCreateDualOutputMiter()

Gia_Man_t * Gia_ManCreateDualOutputMiter	(	Gia_Man_t *	p0,
		Gia_Man_t *	p1 )

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

Synopsis [Computing equivalent nodes across the two AIGs.]

Description [Assumes that both AIGs are structurally hashed without dandling nodes.]

SideEffects []

SeeAlso []

Definition at line 3467 of file giaUtil.c.

{
    Gia_Man_t * pNew; Gia_Obj_t * pObj; int i;
    assert( Gia_ManCiNum(p0) == Gia_ManCiNum(p1) );
    assert( Gia_ManCoNum(p0) == Gia_ManCoNum(p1) );
    // start the manager
    pNew = Gia_ManStart( Gia_ManObjNum(p0) + Gia_ManObjNum(p1) );
    pNew->pName = Abc_UtilStrsav( "miter" );
    Gia_ManFillValue( p0 );
    Gia_ManFillValue( p1 );
    // map combinational inputs
    Gia_ManConst0(p0)->Value = 0;
    Gia_ManConst0(p1)->Value = 0;
    Gia_ManForEachCi( p0, pObj, i )
        Gia_ManCi(p1, i)->Value = pObj->Value = Gia_ManAppendCi( pNew );
    // map internal nodes and outputs
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachAnd( p0, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    assert( Gia_ManAndNum(pNew) == Gia_ManAndNum(p0) ); // the input AIG p0 is structurally hashed
    Gia_ManForEachAnd( p1, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // add the outputs
    Gia_ManForEachCo( p0, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachCo( p1, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    printf( "The two AIGs have %d structurally equivalent nodes.\n", Gia_ManAndNum(p0) + Gia_ManAndNum(p1) - Gia_ManAndNum(pNew) );
    // there should be no dangling nodes (otherwise, the second AIG may not be structurally hashed)
    int nDangling = Gia_ManMarkDangling(pNew);
    assert( nDangling == 0 );
    Gia_ManCleanMark01(pNew);
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCreateLitRefs()

void Gia_ManCreateLitRefs

(

Gia_Man_t *

p

)

Definition at line 799 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    assert( p->pRefs == NULL );
    p->pRefs = ABC_CALLOC( int, 2*Gia_ManObjNum(p) );
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
        {
            p->pRefs[Gia_ObjFaninLit0(pObj, i)]++;
            p->pRefs[Gia_ObjFaninLit1(pObj, i)]++;
        }
        else if ( Gia_ObjIsCo(pObj) )
            p->pRefs[Gia_ObjFaninLit0(pObj, i)]++;
    }
}

Gia_ManCreateMuxRefs()

int * Gia_ManCreateMuxRefs

(

Gia_Man_t *

p

)

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

Synopsis [Assigns references.]

Description []

SideEffects []

SeeAlso []

Definition at line 828 of file giaUtil.c.

{
    Gia_Obj_t * pObj, * pCtrl, * pFan0, * pFan1;
    int i, * pMuxRefs;
    pMuxRefs = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjRecognizeExor( pObj, &pFan0, &pFan1 ) )
            continue;
        if ( !Gia_ObjIsMuxType(pObj) )
            continue;
        pCtrl = Gia_ObjRecognizeMux( pObj, &pFan0, &pFan1 );
        pMuxRefs[ Gia_ObjId(p, Gia_Regular(pCtrl)) ]++;
    }
    return pMuxRefs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManCreateRefs()

void Gia_ManCreateRefs

(

Gia_Man_t *

p

)

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

Synopsis [Assigns references.]

Description []

SideEffects []

SeeAlso []

Definition at line 779 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    assert( p->pRefs == NULL );
    p->pRefs = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjRefFanin0Inc( p, pObj );
            if ( !Gia_ObjIsBuf(pObj) )
                Gia_ObjRefFanin1Inc( p, pObj );
            if ( Gia_ObjIsMuxId(p, i) )
                Gia_ObjRefFanin2Inc( p, pObj );
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjRefFanin0Inc( p, pObj );
    }
}

Gia_ManCreateValueRefs()

void Gia_ManCreateValueRefs

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 750 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
    {
        pObj->Value = 0;
        if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjFanin0(pObj)->Value++;
            if ( !Gia_ObjIsBuf(pObj) )
                Gia_ObjFanin1(pObj)->Value++;
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjFanin0(pObj)->Value++;
    }
}

Here is the caller graph for this function:

Gia_ManCrossCut()

int Gia_ManCrossCut	(	Gia_Man_t *	p,
		int	fReverse )

Definition at line 916 of file giaUtil.c.

{
    Vec_Int_t * vNodes;
    Gia_Obj_t * pObj;
    int i, nCutCur = 0, nCutMax = 0;
    vNodes = Gia_ManDfsForCrossCut( p, fReverse );
    //vNodes = Gia_ManBfsForCrossCut( p );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
    {
        if ( pObj->Value )
            nCutCur++;
        if ( nCutMax < nCutCur )
            nCutMax = nCutCur;
        if ( Gia_ObjIsAnd(pObj) )
        {
            if ( --Gia_ObjFanin0(pObj)->Value == 0 )
                nCutCur--;
            if ( --Gia_ObjFanin1(pObj)->Value == 0 )
                nCutCur--;
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            if ( --Gia_ObjFanin0(pObj)->Value == 0 )
                nCutCur--;
        }
    }
    Vec_IntFree( vNodes );
    Gia_ManForEachObj( p, pObj, i )
        assert( pObj->Value == 0 );
    return nCutMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDetectSims()

Vec_Wrd_t * Gia_ManDetectSims	(	Gia_Man_t *	p,
		int	iCo,
		int	nWords )

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

Synopsis [Transform flops.]

Description []

SideEffects []

SeeAlso []

Definition at line 3051 of file giaUtil.c.

{
    extern int Cec4_ManGeneratePatterns_rec( Gia_Man_t * p, Gia_Obj_t * pObj, int Value, Vec_Int_t * vPat, Vec_Int_t * vVisit );
    Vec_Wrd_t * vSim = Vec_WrdStart( nWords * Gia_ManCiNum(p) );
    Vec_Int_t * vPat = Vec_IntAlloc( Gia_ManCiNum(p) );
    Vec_Int_t * vVis = Vec_IntAlloc( Gia_ManAndNum(p) );
    Gia_Obj_t * pObj = Gia_ManCo( p, iCo ), * pTemp; int iLit, i, k, nTries = 0;
    if ( Gia_ObjFanin0(pObj) == Gia_ManConst0(p) )
        return NULL;
    Gia_ManForEachObj( p, pTemp, k )
        assert( !pTemp->fMark0 && !pTemp->fMark1 );
    for ( i = 0; i < 64*nWords; )
    {
        int Res = Cec4_ManGeneratePatterns_rec( p, Gia_ObjFanin0(pObj), !Gia_ObjFaninC0(pObj), vPat, vVis );
        if ( Res )
        {
            Vec_IntForEachEntry( vPat, iLit, k )
            {
                if ( Abc_LitIsCompl(iLit) )
                    continue;
                pTemp = Gia_ManObj( p, Abc_Lit2Var(iLit) );
                assert( Gia_ObjIsCi(pTemp) );
                Abc_InfoSetBit( (unsigned *)Vec_WrdEntryP(vSim, nWords*Gia_ObjCioId(pTemp)), i );
            }
            i++;
        }
        Gia_ManForEachObjVec( vVis, p, pTemp, k )
            pTemp->fMark0 = pTemp->fMark1 = 0;
        nTries++;
    }
    //printf( "%d ", nTries );
    Vec_IntFree( vPat );
    Vec_IntFree( vVis );
    return vSim;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDfsForCrossCut()

Vec_Int_t * Gia_ManDfsForCrossCut	(	Gia_Man_t *	p,
		int	fReverse )

Definition at line 894 of file giaUtil.c.

{
    Vec_Int_t * vNodes;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManCleanValue( p );
    vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
    Gia_ManIncrementTravId( p );
    if ( fReverse )
    {
        Gia_ManForEachCoReverse( p, pObj, i )
            if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) )
                Gia_ManDfsForCrossCut_rec( p, pObj, vNodes );
    }
    else
    {
        Gia_ManForEachCo( p, pObj, i )
            if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) )
                Gia_ManDfsForCrossCut_rec( p, pObj, vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDfsForCrossCut_rec()

void Gia_ManDfsForCrossCut_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vNodes )

Definition at line 870 of file giaUtil.c.

{
    if ( Gia_ObjIsTravIdCurrent(p, pObj) )
        return;
    Gia_ObjSetTravIdCurrent(p, pObj);
    if ( Gia_ObjIsCi(pObj) )
    {
        Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
        return;
    }
    if ( Gia_ObjIsCo(pObj) )
    {
        Gia_ObjFanin0(pObj)->Value++;
        Gia_ManDfsForCrossCut_rec( p, Gia_ObjFanin0(pObj), vNodes );
        Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
        return;
    }
    assert( Gia_ObjIsAnd(pObj) );
    Gia_ObjFanin0(pObj)->Value++;
    Gia_ObjFanin1(pObj)->Value++;
    Gia_ManDfsForCrossCut_rec( p, Gia_ObjFanin0(pObj), vNodes );
    Gia_ManDfsForCrossCut_rec( p, Gia_ObjFanin1(pObj), vNodes );
    Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDumpSuppFile()

void Gia_ManDumpSuppFile	(	Vec_Str_t *	p,
		char *	pFileName )

Definition at line 2845 of file giaUtil.c.

{
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
    else
    {
        int nOuts = Vec_StrCountEntry(p, '\n');
        int nIns  = Vec_StrSize(p)/Vec_StrCountEntry(p, '\n') - 1;
        int nSize1 = Vec_StrSize(p) - 1;
        int nSize2 = fwrite( Vec_StrArray(p), 1, nSize1, pFile );
        assert( nSize1 == nSize2 );
        printf( "Successfully dumped file \"%s\" with support data for %d outputs and %d inputs.\n", pFileName, nOuts, nIns );
    }
    fclose( pFile );
}

Here is the caller graph for this function:

Gia_ManDumpSuppFileTest()

void Gia_ManDumpSuppFileTest	(	Gia_Man_t *	p,
		char *	pFileName )

Definition at line 2873 of file giaUtil.c.

{
    Vec_Wec_t * vSupps  = Gia_ManComputeSupports( p );
    Vec_Str_t * vRes    = Gia_ManConvertDump( p, vSupps );
    Gia_ManDumpSuppFile( vRes, pFileName );
    Vec_WecFree( vSupps );
    Vec_StrFree( vRes );
}

Here is the call graph for this function:

Gia_ManDumpSuppFileTest3()

void Gia_ManDumpSuppFileTest3	(	Gia_Man_t *	p,
		char *	pFileName )

Definition at line 2861 of file giaUtil.c.

{
    Vec_Wec_t * vSupps  = Gia_ManComputeSupports( p );
    Vec_Wec_t * vDiffs  = Gia_ManComputeSharing( vSupps );
    Vec_Wec_t * vDiffs2 = Gia_ManComputeSharing( vDiffs );
    Vec_Str_t * vRes    = Gia_ManConvertDump( p, vDiffs2 );
    Gia_ManDumpSuppFile( vRes, pFileName );
    Vec_WecFree( vDiffs2 );
    Vec_WecFree( vDiffs );
    Vec_WecFree( vSupps );
    Vec_StrFree( vRes );
}

Here is the call graph for this function:

Gia_ManDupInsertWindows()

Gia_Man_t * Gia_ManDupInsertWindows	(	Gia_Man_t *	p,
		Vec_Ptr_t *	vvIns,
		Vec_Ptr_t *	vvOuts,
		Vec_Ptr_t *	vWins )

Definition at line 3418 of file giaUtil.c.

{
    // check consistency of input data
    Gia_Man_t * pNew, * pTemp; Gia_Obj_t * pObj; int i, k, iNode;
    Vec_PtrForEachEntry( Gia_Man_t *, vWins, pTemp, i ) {
        Vec_Int_t * vIns  = (Vec_Int_t *)Vec_PtrEntry(vvIns, i);
        Vec_Int_t * vOuts = (Vec_Int_t *)Vec_PtrEntry(vvOuts, i);
        assert( Vec_IntSize(vIns)  == Gia_ManPiNum(pTemp) );
        assert( Vec_IntSize(vOuts) == Gia_ManPoNum(pTemp) );
        assert( !Gia_ManWindowCheckTopoError(p, vIns, vOuts) );        
    }
    // create mapping of window outputs into window IDs
    Vec_Int_t * vMap = Vec_IntStartFull( Gia_ManObjNum(p) ), * vOuts;
    Vec_PtrForEachEntry( Vec_Int_t *, vvOuts, vOuts, i )
        Vec_IntForEachEntry( vOuts, iNode, k )
            Vec_IntWriteEntry( vMap, iNode, i );
    // create the resulting AIG by performing DFS from the POs of the original AIG
    // it goes recursively through original nodes and windows until it reaches the PIs of the original AIG
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );    
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupInsertWindows_rec( pNew, p, Gia_ObjFanin0(pObj), vMap, vvIns, vvOuts, vWins );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    // cleanup and return
    Vec_IntFree( vMap );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    //Gia_ManPrint( pNew );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDupInsertWindows_rec()

int Gia_ManDupInsertWindows_rec	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vMap,
		Vec_Ptr_t *	vvIns,
		Vec_Ptr_t *	vvOuts,
		Vec_Ptr_t *	vWins )

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

Synopsis [Updates the AIG after multiple windows have been optimized.]

Description []

SideEffects []

SeeAlso []

Definition at line 3388 of file giaUtil.c.

{
    if ( ~pObj->Value )
        return pObj->Value;
    assert( Gia_ObjIsAnd(pObj) );
    if ( Vec_IntEntry(vMap, Gia_ObjId(p, pObj)) == -1 ) // this is a regular node
    {
        Gia_ManDupInsertWindows_rec( pNew, p, Gia_ObjFanin0(pObj), vMap, vvIns, vvOuts, vWins );
        Gia_ManDupInsertWindows_rec( pNew, p, Gia_ObjFanin1(pObj), vMap, vvIns, vvOuts, vWins );
        return pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    }
    // this node is an output of a window
    int iWin = Vec_IntEntry(vMap, Gia_ObjId(p, pObj));
    Vec_Int_t * vIns  = (Vec_Int_t *)Vec_PtrEntry(vvIns, iWin);
    Vec_Int_t * vOuts = (Vec_Int_t *)Vec_PtrEntry(vvOuts, iWin);
    Gia_Man_t * pWin  = (Gia_Man_t *)Vec_PtrEntry(vWins, iWin);
    // build transinvite fanins of window inputs
    Gia_Obj_t * pNode; int i;
    Gia_ManConst0(pWin)->Value = 0;
    Gia_ManForEachObjVec( vIns, p, pNode, i )
        Gia_ManPi(pWin, i)->Value = Gia_ManDupInsertWindows_rec( pNew, p, pNode, vMap, vvIns, vvOuts, vWins );
    // add window nodes
    Gia_ManForEachAnd( pWin, pNode, i )
        pNode->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pNode), Gia_ObjFanin1Copy(pNode) );
    // transfer to window outputs
    Gia_ManForEachObjVec( vOuts, p, pNode, i )
        pNode->Value = Gia_ObjFanin0Copy(Gia_ManPo(pWin, i));
    assert( ~pObj->Value );
    return pObj->Value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManDupWithMuxPos()

Gia_Man_t * Gia_ManDupWithMuxPos

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2379 of file giaUtil.c.

{
    Vec_Int_t * vPoints = Vec_IntAlloc( 1000 );
    Vec_Int_t * vQuads  = Vec_IntAlloc( 1000 );
    Vec_Bit_t * vHeads  = Vec_BitStart( Gia_ManObjNum(p) );
    Vec_Bit_t * vDatas  = Vec_BitStart( Gia_ManObjNum(p) );
    Gia_Obj_t * pObj, * pCtrl, * pData0, * pData1;
    Gia_Man_t * pNew = Gia_ManDup( p ); int i, iObj;
    assert( Gia_ManRegNum(pNew) == 0 );
    Gia_ManForEachAnd( pNew, pObj, i )
    {
        if ( !Gia_ObjIsMuxType(pObj) )
            continue;
        pCtrl  = Gia_ObjRecognizeMux( pObj, &pData1, &pData0 );
        pCtrl  = Gia_Regular(pCtrl);
        pData0 = Gia_Regular(pData0);
        pData1 = Gia_Regular(pData1);
        Vec_IntPushTwo( vQuads, Gia_ObjId(pNew, pObj),   Gia_ObjId(pNew, pCtrl)  );
        Vec_IntPushTwo( vQuads, Gia_ObjId(pNew, pData0), Gia_ObjId(pNew, pData1) );
        Vec_BitWriteEntry( vHeads, Gia_ObjId(pNew, pObj),   1 );
        Vec_BitWriteEntry( vDatas, Gia_ObjId(pNew, pData0), 1 );
        Vec_BitWriteEntry( vDatas, Gia_ObjId(pNew, pData1), 1 );
    }
    Gia_ManForEachCo( pNew, pObj, i )
        Gia_ObjFanin0(pObj)->fMark0 = 1;
    for ( i = 0; i < Vec_IntSize(vQuads)/4; i++ )
    {
        int iObj   = Vec_IntEntry( vQuads, 4*i+0 );
        int iCtrl  = Vec_IntEntry( vQuads, 4*i+1 );
        int iData0 = Vec_IntEntry( vQuads, 4*i+2 );
        int iData1 = Vec_IntEntry( vQuads, 4*i+3 );
        if ( (Vec_BitEntry(vHeads, iObj)   && Vec_BitEntry(vDatas, iObj))   || 
             (Vec_BitEntry(vHeads, iData0) && Vec_BitEntry(vDatas, iData0)) || 
             (Vec_BitEntry(vHeads, iData1) && Vec_BitEntry(vDatas, iData1)) )
        {
            Gia_Obj_t * pObj   = Gia_ManObj( p, iObj );
            Gia_Obj_t * pCtrl  = Gia_ManObj( p, iCtrl );
            Gia_Obj_t * pData0 = Gia_ManObj( p, iData0 );
            Gia_Obj_t * pData1 = Gia_ManObj( p, iData1 );
            if ( Gia_ObjIsAnd(pObj)   && !pObj->fMark0   )  Vec_IntPush( vPoints, iObj   );
            if ( Gia_ObjIsAnd(pCtrl)  && !pCtrl->fMark0  )  Vec_IntPush( vPoints, iCtrl  );
            if ( Gia_ObjIsAnd(pData0) && !pData0->fMark0 )  Vec_IntPush( vPoints, iData0 );
            if ( Gia_ObjIsAnd(pData1) && !pData1->fMark0 )  Vec_IntPush( vPoints, iData1 );
        }
    }
    Gia_ManCleanMark0( pNew );
    Vec_IntUniqify( vPoints );
    Vec_IntForEachEntry( vPoints, iObj, i )
        Gia_ManAppendCo( pNew, Abc_Var2Lit(iObj, 0) );
    Vec_IntFree( vPoints );
    Vec_IntFree( vQuads );
    Vec_BitFree( vHeads );
    Vec_BitFree( vDatas );
    return pNew;
}

Here is the call graph for this function:

Gia_ManFillValue()

void Gia_ManFillValue

(

Gia_Man_t *

p

)

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

Synopsis [Cleans the value.]

Description []

SideEffects []

SeeAlso []

Definition at line 369 of file giaUtil.c.

{
    int i;
    for ( i = 0; i < p->nObjs; i++ )
        p->pObjs[i].Value = ~0;
}

Gia_ManFindMutualEquivs()

Vec_Int_t * Gia_ManFindMutualEquivs	(	Gia_Man_t *	p0,
		Gia_Man_t *	p1,
		int	nConflictLimit,
		int	fVerbose )

Definition at line 3501 of file giaUtil.c.

{
    Vec_Int_t * vPairs = Vec_IntAlloc( 100 );
    // derive the miter
    Gia_Man_t * pMiter = Gia_ManCreateDualOutputMiter( p0, p1 );
    //Gia_ManPrintStats( pMiter, NULL );
    //Gia_AigerWrite( pMiter, "out.aig", 0, 0, 0 );
    // perform SAT sweeping
    extern Gia_Man_t * Cec4_ManSimulateTest3( Gia_Man_t * p, int nBTLimit, int fVerbose );
    Gia_Man_t * pNew = Cec4_ManSimulateTest3( pMiter, nConflictLimit, fVerbose );
    Gia_ManStop( pNew );
    // now, pMiter is annotated with the equiv class info
 
    // here we collect AIG node pairs with the following properties:
    // - the first node belongs to p0; the second node belongs to p1
    // - both nodes are internal nodes of p0 and p1 (not primary inputs/outputs)
    // - these nodes are combinationally equivalent (possibly up to the complement)
    // - these nodes are "singleton" equivalences (no other nodes in p0 and p1 are equivalent to them)
    // - these nodes are not structurally equivalent (that is, they have structurally different TFI logic cones)
 
    // count the number of nodes in each equivalence class
    Vec_Int_t * vCounts = Vec_IntStart( Gia_ManObjNum(pMiter) );
    Gia_Obj_t * pObj; int i, k;
    Gia_ManForEachClass( pMiter, i ) 
        Gia_ClassForEachObj( pMiter, i, k )
            Vec_IntAddToEntry( vCounts, i, 1 );
 
    // map each miter node coming from p1 into the corresponding node in p1
    Vec_Int_t * vMap = Vec_IntStartFull( Gia_ManObjNum(pMiter) );
    int iStartP1 = 1 + Gia_ManPiNum(p0) + Gia_ManAndNum(p0);
    Gia_ManForEachAnd( p1, pObj, i )
        if ( Abc_Lit2Var(pObj->Value) >= iStartP1 ) // node from p1 (not from p0)
            Vec_IntWriteEntry( vMap, Abc_Lit2Var(pObj->Value), i );
 
    // go through functionally (not structurally!) equivalent nodes in the second AIG
    // and collect those node pairs from p0 and p1 whose equivalence class contains exactly two nodes
    for ( i = iStartP1; i < Gia_ManObjNum(pMiter) - Gia_ManCoNum(pMiter); i++ ) {
        assert( Gia_ObjIsAnd(Gia_ManObj(pMiter, i)) );
        int Repr = Gia_ObjRepr(pMiter, i);
        if ( Repr == GIA_VOID || Repr >= iStartP1 || Vec_IntEntry(vCounts, Repr) != 2 )
            continue;
        assert( Repr < iStartP1 );           // node in p0
        assert( Vec_IntEntry(vMap, i) > 0 ); // node in p1
        Vec_IntPushTwo( vPairs, Repr, Vec_IntEntry(vMap, i) );
    }
    // cleanup
    Vec_IntFree( vMap );
    Vec_IntFree( vCounts );
    Gia_ManStop( pMiter );
    return vPairs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManFindMutualEquivsTest()

void Gia_ManFindMutualEquivsTest

(

)

Definition at line 3552 of file giaUtil.c.

{
    Gia_Man_t * p0 = Gia_AigerRead( "p0.aig", 0, 0, 0 );
    Gia_Man_t * p1 = Gia_AigerRead( "p1.aig", 0, 0, 0 );    
    Vec_Int_t * vPairs = Gia_ManFindMutualEquivs( p0, p1, 0, 0 );
    printf( "Pair     Aig0 node     Aig1 node\n" );
    int i, Obj0, Obj1;
    Vec_IntForEachEntryDouble( vPairs, Obj0, Obj1, i )
        printf( "%3d      %6d       %6d\n", i/2, Obj0, Obj1 );
    Gia_ManStop( p0 );
    Gia_ManStop( p1 );
    Vec_IntFree( vPairs );
}

Here is the call graph for this function:

Gia_ManFirstFanouts()

Vec_Int_t * Gia_ManFirstFanouts

(

Gia_Man_t *

p

)

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

Synopsis [Returns the array containing the first fanout of each object.]

Description []

SideEffects []

SeeAlso []

Definition at line 1861 of file giaUtil.c.

{
    Vec_Int_t * vFans = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
        {
            if ( Vec_IntEntry(vFans, Gia_ObjFaninId0p(p, pObj)) == 0 )
                Vec_IntWriteEntry(vFans, Gia_ObjFaninId0p(p, pObj), i);
            if ( Vec_IntEntry(vFans, Gia_ObjFaninId1p(p, pObj)) == 0 )
                Vec_IntWriteEntry(vFans, Gia_ObjFaninId1p(p, pObj), i);
            if ( Gia_ObjIsMuxId(p, i) && Vec_IntEntry(vFans, Gia_ObjFaninId2p(p, pObj)) == 0 )
                Vec_IntWriteEntry(vFans, Gia_ObjFaninId2p(p, pObj), i);
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            if ( Vec_IntEntry(vFans, Gia_ObjFaninId0p(p, pObj)) == 0 )
                Vec_IntWriteEntry(vFans, Gia_ObjFaninId0p(p, pObj), i);
        }
    }
    return vFans;
}

Here is the caller graph for this function:

Gia_ManGetCiLevels()

Vec_Int_t * Gia_ManGetCiLevels

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels using CI level information.]

Description []

SideEffects []

SeeAlso []

Definition at line 609 of file giaUtil.c.

{
    Vec_Int_t * vCiLevels;
    Gia_Obj_t * pObj;
    int i;
    if ( p->vLevels == NULL )
        return NULL;
    vCiLevels = Vec_IntAlloc( Gia_ManCiNum(p) );
    Gia_ManForEachCi( p, pObj, i )
        Vec_IntPush( vCiLevels, Gia_ObjLevel(p, pObj) );
    return vCiLevels;
}

Here is the caller graph for this function:

Gia_ManGetDangling()

Vec_Int_t * Gia_ManGetDangling

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has dangling nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1422 of file giaUtil.c.

{
    Vec_Int_t * vDangles;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
    {
        pObj->fMark0 = 0;
        if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjFanin0(pObj)->fMark0 = 1;
            Gia_ObjFanin1(pObj)->fMark0 = 1;
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjFanin0(pObj)->fMark0 = 1;
    }
    vDangles = Vec_IntAlloc( 100 );
    Gia_ManForEachAnd( p, pObj, i )
        if ( !pObj->fMark0 )
            Vec_IntPush( vDangles, i );
    Gia_ManCleanMark0( p );
    return vDangles;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManGroupProve()

Vec_Int_t * Gia_ManGroupProve	(	Gia_Man_t *	pInit,
		char *	pCommLine,
		int	nGroupSize,
		int	fVerbose )

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

Synopsis [Proving multi-output properties.]

Description []

SideEffects []

SeeAlso []

Definition at line 1989 of file giaUtil.c.

{
    Abc_Frame_t * pAbc = Abc_FrameReadGlobalFrame();
    Gia_Man_t * p = Gia_ManDup( pInit );
    Gia_Man_t * pGroup;
    Vec_Int_t * vOuts;
    Vec_Int_t * vOutMap;
    Vec_Ptr_t * vCexes;
    int i, k, nGroupCur, nGroups;
    abctime clk, timeComm = 0;
    abctime timeStart = Abc_Clock();
    // pre-conditions
    assert( nGroupSize > 0 );
    assert( pCommLine != NULL );
    assert( p->nConstrs == 0 );
    Abc_Print( 1, "RUNNING MultiProve: Group size = %d. Command line = \"%s\".\n", nGroupSize, pCommLine );
    // create output map
    vOuts   = Vec_IntStartNatural( Gia_ManPoNum(p) );
    vOutMap = Vec_IntAlloc( Gia_ManPoNum(p) );
    vCexes  = Vec_PtrAlloc( Gia_ManPoNum(p) );
    nGroups = Gia_ManPoNum(p) / nGroupSize + (int)((Gia_ManPoNum(p) % nGroupSize) > 0);
    for ( i = 0; i < nGroups; i++ )
    {
        // derive the group
        nGroupCur = ((i + 1) * nGroupSize < Gia_ManPoNum(p)) ? nGroupSize : Gia_ManPoNum(p) - i * nGroupSize;
        pGroup = Gia_ManDupCones( p, Vec_IntArray(vOuts) + i * nGroupSize, nGroupCur, 0 );
        Abc_Print( 1, "GROUP %4d : %4d <= PoId < %4d : ", i, i * nGroupSize, i * nGroupSize + nGroupCur );
        // set the current GIA
        Abc_FrameUpdateGia( pAbc, pGroup );
        // solve the group
        clk = Abc_Clock();
        Cmd_CommandExecute( pAbc, pCommLine );
        timeComm += Abc_Clock() - clk;
        // get the solution status
        if ( nGroupSize == 1 )
        {
            Vec_IntPush( vOutMap, Abc_FrameReadProbStatus(pAbc) );
            Vec_PtrPush( vCexes, Abc_FrameReadCex(pAbc) );
        }
        else // if ( nGroupSize > 1 )  
        {
            Vec_Int_t * vStatusCur = Abc_FrameReadPoStatuses( pAbc );
            Vec_Ptr_t * vCexesCur = Abc_FrameReadCexVec( pAbc );
            assert( vStatusCur != NULL ); // only works for "bmc3" and "pdr"
//            assert( vCexesCur != NULL );
            for ( k = 0; k < nGroupCur; k++ )
            {
                Vec_IntPush( vOutMap, Vec_IntEntry(vStatusCur, k) );
                Vec_PtrPush( vCexes, vCexesCur ? Vec_PtrEntry(vCexesCur, k) : NULL );
            }
        }
    }
    assert( Vec_PtrSize(vCexes) == Gia_ManPoNum(p) );
    assert( Vec_IntSize(vOutMap) == Gia_ManPoNum(p) );
    // set CEXes
    if ( Vec_PtrCountZero(vCexes) < Vec_PtrSize(vCexes) )
        Abc_FrameReplaceCexVec( pAbc, &vCexes );
    else  // there is no CEXes
        Vec_PtrFree( vCexes );
    // report the result
    Abc_Print( 1, "SUMMARY:  " );
    Abc_Print( 1, "Properties = %6d. ", Gia_ManPoNum(p) );
    Abc_Print( 1, "UNSAT = %6d. ",      Vec_IntCountEntry(vOutMap, 1) );
    Abc_Print( 1, "SAT = %6d. ",        Vec_IntCountEntry(vOutMap, 0) );
    Abc_Print( 1, "UNDEC = %6d. ",      Vec_IntCountEntry(vOutMap, -1) );
    Abc_Print( 1, "\n" );
    Abc_PrintTime( 1, "Command time", timeComm );
    Abc_PrintTime( 1, "Total time  ", Abc_Clock() - timeStart );
    // cleanup
    Vec_IntFree( vOuts );
    Gia_ManStop( p );
    return vOutMap;
}

Here is the call graph for this function:

Gia_ManHasChoices_very_old()

int Gia_ManHasChoices_very_old

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has choices.]

Description []

SideEffects []

SeeAlso []

Definition at line 1897 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, Counter1 = 0, Counter2 = 0;
    int nFailNoRepr = 0;
    int nFailHaveRepr = 0;
    int nChoiceNodes = 0;
    int nChoices = 0;
    if ( p->pReprs == NULL || p->pNexts == NULL )
        return 0;
    // check if there are any representatives
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjReprObj( p, Gia_ObjId(p, pObj) ) )
        {
//            printf( "%d ", i );
            Counter1++;
        }
//        if ( Gia_ObjNext( p, Gia_ObjId(p, pObj) ) )
//            Counter2++;
    }
//    printf( "\n" );
    Gia_ManForEachObj( p, pObj, i )
    {
//        if ( Gia_ObjReprObj( p, Gia_ObjId(p, pObj) ) )
//            Counter1++;
        if ( Gia_ObjNext( p, Gia_ObjId(p, pObj) ) )
        {
//            printf( "%d ", i );
            Counter2++;
        }
    }
//    printf( "\n" );
    if ( Counter1 == 0 )
    {
        printf( "Warning: AIG has repr data-strucure but not reprs.\n" );
        return 0;
    }
    printf( "%d nodes have reprs.\n", Counter1 );
    printf( "%d nodes have nexts.\n", Counter2 );
    // check if there are any internal nodes without fanout
    // make sure all nodes without fanout have representatives
    // make sure all nodes with fanout have no representatives
    ABC_FREE( p->pRefs );
    Gia_ManCreateRefs( p );
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( Gia_ObjRefNum(p, pObj) == 0 )
        {
            if ( Gia_ObjReprObj( p, Gia_ObjId(p, pObj) ) == NULL )
                nFailNoRepr++;
            else
                nChoices++;
        }
        else
        {
            if ( Gia_ObjReprObj( p, Gia_ObjId(p, pObj) ) != NULL )
                nFailHaveRepr++;
            if ( Gia_ObjNextObj( p, Gia_ObjId(p, pObj) ) != NULL )
                nChoiceNodes++;
        }
        if ( Gia_ObjReprObj( p, i ) )
            assert( Gia_ObjRepr(p, i) < i );
    }
    if ( nChoices == 0 )
        return 0;
    if ( nFailNoRepr )
    {
        printf( "Gia_ManHasChoices_very_old(): Error: %d internal nodes have no fanout and no repr.\n", nFailNoRepr );
//        return 0;
    }
    if ( nFailHaveRepr )
    {
        printf( "Gia_ManHasChoices_very_old(): Error: %d internal nodes have both fanout and repr.\n", nFailHaveRepr );
//        return 0;
    }
//    printf( "Gia_ManHasChoices_very_old(): AIG has %d choice nodes with %d choices.\n", nChoiceNodes, nChoices );
    return 1;
}

Here is the call graph for this function:

Gia_ManHasDangling()

int Gia_ManHasDangling

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has dangling nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1353 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0;
    Gia_ManForEachObj( p, pObj, i )
    {
        pObj->fMark0 = 0;
        if ( Gia_ObjIsCo(pObj) )
            Gia_ObjFanin0(pObj)->fMark0 = 1;
        else if ( Gia_ObjIsMux(p, pObj) )
        {
            Gia_ObjFanin0(pObj)->fMark0 = 1;
            Gia_ObjFanin1(pObj)->fMark0 = 1;
            Gia_ObjFanin2(p, pObj)->fMark0 = 1;
        }
        else if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjFanin0(pObj)->fMark0 = 1;
            Gia_ObjFanin1(pObj)->fMark0 = 1;
        }
    }
    Gia_ManForEachAnd( p, pObj, i )
        Counter += !pObj->fMark0;
    Gia_ManCleanMark0( p );
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManIncrementTravId()

void Gia_ManIncrementTravId

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 190 of file giaUtil.c.

{ 
    if ( p->pTravIds == NULL )
    {
        p->nTravIdsAlloc = Gia_ManObjNum(p) + 100; 
        p->pTravIds = ABC_CALLOC( int, p->nTravIdsAlloc ); 
        p->nTravIds = 0;  
    }
    while ( p->nTravIdsAlloc < Gia_ManObjNum(p) )
    {
        p->nTravIdsAlloc *= 2;
        p->pTravIds = ABC_REALLOC( int, p->pTravIds, p->nTravIdsAlloc );
        memset( p->pTravIds + p->nTravIdsAlloc/2, 0, sizeof(int) * p->nTravIdsAlloc/2 );
    }
    p->nTravIds++;                                                    
}

Here is the call graph for this function:

Gia_ManInvertConstraints()

void Gia_ManInvertConstraints

(

Gia_Man_t *

pAig

)

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

Synopsis [Complements the constraint outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1641 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    if ( Gia_ManConstrNum(pAig) == 0 )
        return;
    Gia_ManForEachPo( pAig, pObj, i )
        if ( i >= Gia_ManPoNum(pAig) - Gia_ManConstrNum(pAig) )
            Gia_ObjFlipFaninC0( pObj );
}

Here is the caller graph for this function:

Gia_ManInvertPos()

void Gia_ManInvertPos

(

Gia_Man_t *

pAig

)

Definition at line 1651 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachPo( pAig, pObj, i )
        Gia_ObjFlipFaninC0( pObj );
}

Here is the caller graph for this function:

Gia_ManLevelAve()

float Gia_ManLevelAve

(

Gia_Man_t *

p

)

Definition at line 588 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, Ave = 0;
    assert( p->vLevels );
    Gia_ManForEachCo( p, pObj, i )
        Ave += Gia_ObjLevel(p, pObj);
    return (float)Ave / Gia_ManCoNum(p);
}

Here is the caller graph for this function:

Gia_ManLevelNum()

int Gia_ManLevelNum

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 546 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManCleanLevels( p, Gia_ManObjNum(p) );
    p->nLevels = 0;
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( !p->fGiaSimple && Gia_ObjIsBuf(pObj) )
            Gia_ObjSetBufLevel( p, pObj );
        else if ( Gia_ObjIsAnd(pObj) )
            Gia_ObjSetGateLevel( p, pObj );
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjSetCoLevel( p, pObj );
        else
            Gia_ObjSetLevel( p, pObj, 0 );
        p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
    }
    return p->nLevels;
}

Here is the call graph for this function:

Gia_ManLevelRNum()

int Gia_ManLevelRNum

(

Gia_Man_t *

p

)

Definition at line 566 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManCleanLevels( p, Gia_ManObjNum(p) );
    p->nLevels = 0;
    Gia_ManForEachObjReverse( p, pObj, i )
    {
        if ( !p->fGiaSimple && Gia_ObjIsBuf(pObj) )
            Gia_ObjUpdateLevelId( p, Gia_ObjFaninId0(pObj, i), Gia_ObjLevel(p, pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjUpdateLevelId( p, Gia_ObjFaninId0(pObj, i), 1+Gia_ObjLevel(p, pObj) );
            Gia_ObjUpdateLevelId( p, Gia_ObjFaninId1(pObj, i), 1+Gia_ObjLevel(p, pObj) );
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjUpdateLevelId( p, Gia_ObjFaninId0(pObj, i), 1 );
        else
            p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
    }
    return p->nLevels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManLoadValue()

void Gia_ManLoadValue	(	Gia_Man_t *	p,
		Vec_Int_t *	vValues )

Definition at line 1841 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->Value = Vec_IntEntry(vValues, i);
}

Gia_ManMarkDangling()

int Gia_ManMarkDangling

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has dangling nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1391 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0;
    Gia_ManForEachObj( p, pObj, i )
    {
        pObj->fMark0 = 0;
        if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjFanin0(pObj)->fMark0 = 1;
            Gia_ObjFanin1(pObj)->fMark0 = 1;
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjFanin0(pObj)->fMark0 = 1;
    }
    Gia_ManForEachAnd( p, pObj, i )
        Counter += !pObj->fMark0;
    return Counter;
}

Here is the caller graph for this function:

Gia_ManMarkFanoutDrivers()

void Gia_ManMarkFanoutDrivers

(

Gia_Man_t *

p

)

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

Synopsis [Marks nodes that appear as faninis of other nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1779 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
    {
        pObj->fMark0 = 0;
        if ( Gia_ObjIsAnd(pObj) )
        {
            Gia_ObjFanin0(pObj)->fMark0 = 1;
            Gia_ObjFanin1(pObj)->fMark0 = 1;
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjFanin0(pObj)->fMark0 = 1;
    }
}

Here is the caller graph for this function:

Gia_ManPoMffcSize()

int Gia_ManPoMffcSize

(

Gia_Man_t *

p

)

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

Synopsis [References the node's MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 1213 of file giaUtil.c.

{
    Gia_ManCreateRefs( p );
    return Gia_NodeDeref_rec( p, Gia_ObjFanin0(Gia_ManPo(p, 0)) );
}

Here is the call graph for this function:

Gia_ManPoXSim()

Vec_Int_t * Gia_ManPoXSim	(	Gia_Man_t *	p,
		int	nFrames,
		int	fVerbose )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2075 of file giaUtil.c.

{
    Vec_Int_t * vRes;
    Gia_Obj_t * pObj;
    int f, k, nLeft = Gia_ManPoNum(p);
    vRes = Vec_IntAlloc( Gia_ManPoNum(p) );
    Vec_IntFill( vRes, Gia_ManPoNum(p), nFrames );
    Gia_ObjTerSimSet0( Gia_ManConst0(p) );
    Gia_ManForEachRi( p, pObj, k )
        Gia_ObjTerSimSet0( pObj );
    for ( f = 0; f < nFrames; f++ )
    {
        Gia_ManForEachPi( p, pObj, k )
            Gia_ObjTerSimSetX( pObj );
        Gia_ManForEachRo( p, pObj, k )
            Gia_ObjTerSimRo( p, pObj );
        Gia_ManForEachAnd( p, pObj, k )
            Gia_ObjTerSimAnd( pObj );
        Gia_ManForEachCo( p, pObj, k )
            Gia_ObjTerSimCo( pObj );
        if ( fVerbose )
        {
            Gia_ManForEachPo( p, pObj, k )
                Gia_ObjTerSimPrint( pObj );
            printf( "\n" );
        }
        Gia_ManForEachPo( p, pObj, k )
            if ( Vec_IntEntry(vRes, k) == nFrames && Gia_ObjTerSimGetX(pObj) )
                Vec_IntWriteEntry(vRes, k, f), nLeft--;
        if ( nLeft == 0 )
            break;
    }
    if ( fVerbose )
    {
        if ( nLeft == 0 )
            printf( "Simulation converged after %d frames.\n", f+1 );
        else
            printf( "Simulation terminated after %d frames.\n", nFrames );
    }        
//    Vec_IntPrint( vRes );
    return vRes;
}

Gia_ManPrint()

void Gia_ManPrint

(

Gia_Man_t *

p

)

Definition at line 1543 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    printf( "GIA manager has %d ANDs, %d XORs, %d MUXes.\n", 
        Gia_ManAndNum(p) - Gia_ManXorNum(p) - Gia_ManMuxNum(p), Gia_ManXorNum(p), Gia_ManMuxNum(p) ); 
    Gia_ManForEachObj( p, pObj, i )
        Gia_ObjPrint( p, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManPrintArray()

void Gia_ManPrintArray

(

Gia_Man_t *

p

)

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

Synopsis [Transform flops.]

Description []

SideEffects []

SeeAlso []

Definition at line 3203 of file giaUtil.c.

{
    Gia_Obj_t * pObj; int i, nSize = Gia_ManObjNum(p);
    printf( "static int s_ArraySize = %d;\n", nSize );
    printf( "static int s_ArrayData[%d] = {\n", 2*nSize );
    printf( "    0, 0," );
    printf( "\n    " );
    Gia_ManForEachCi( p, pObj, i )
        printf( "0, 0,  " );
    printf( "\n    " );
    Gia_ManForEachAnd( p, pObj, i )
        printf( "%d, %d,  ", Gia_ObjFaninLit0p(p, pObj), Gia_ObjFaninLit1p(p, pObj) );
    printf( "\n    " );
    Gia_ManForEachCo( p, pObj, i )
        printf( "%d, %d,  ", Gia_ObjFaninLit0p(p, pObj), Gia_ObjFaninLit0p(p, pObj) );
    printf( "\n" );
    printf( "};\n" );
 
}

Gia_ManPrintCo()

void Gia_ManPrintCo	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

Definition at line 1563 of file giaUtil.c.

{
    assert( Gia_ObjIsCo(pObj) );
    printf( "TFI cone of CO number %d:\n", Gia_ObjCioId(pObj) );
    Gia_ManPrintCo_rec( p, Gia_ObjFanin0(pObj) );
    Gia_ObjPrint( p, pObj );
}

Here is the call graph for this function:

Gia_ManPrintCo_rec()

void Gia_ManPrintCo_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

Definition at line 1552 of file giaUtil.c.

{
    if ( Gia_ObjIsAnd(pObj) )
    {
        Gia_ManPrintCo_rec( p, Gia_ObjFanin0(pObj) );
        Gia_ManPrintCo_rec( p, Gia_ObjFanin1(pObj) );
        if ( Gia_ObjIsMux(p, pObj) )
            Gia_ManPrintCo_rec( p, Gia_ObjFanin2(p, pObj) );
    }
    Gia_ObjPrint( p, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManPrintCollect2_rec()

void Gia_ManPrintCollect2_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vNodes )

Definition at line 1606 of file giaUtil.c.

{
    if ( Vec_IntFind(vNodes, Gia_ObjId(p, pObj)) >= 0 )
        return;
    if ( Gia_ObjIsCo(pObj) || Gia_ObjIsAnd(pObj) )
        Gia_ManPrintCollect2_rec( p, Gia_ObjFanin0(pObj), vNodes );
    if ( Gia_ObjIsAnd(pObj) )
        Gia_ManPrintCollect2_rec( p, Gia_ObjFanin1(pObj), vNodes );
    if ( Gia_ObjIsMux(p, pObj) )
        Gia_ManPrintCollect2_rec( p, Gia_ObjFanin2(p, pObj), vNodes );
    Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManPrintCollect_rec()

void Gia_ManPrintCollect_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vNodes )

Definition at line 1571 of file giaUtil.c.

{
    if ( Vec_IntFind(vNodes, Gia_ObjId(p, pObj)) >= 0 )
        return;
    assert( Gia_ObjIsAnd(pObj) );
    Gia_ManPrintCollect_rec( p, Gia_ObjFanin0(pObj), vNodes );
    Gia_ManPrintCollect_rec( p, Gia_ObjFanin1(pObj), vNodes );
    if ( Gia_ObjIsMux(p, pObj) )
        Gia_ManPrintCollect_rec( p, Gia_ObjFanin2(p, pObj), vNodes );
    Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManPrintCone()

void Gia_ManPrintCone	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		int *	pLeaves,
		int	nLeaves,
		Vec_Int_t *	vNodes )

Definition at line 1582 of file giaUtil.c.

{
    int i;
    Vec_IntClear( vNodes );
    for ( i = 0; i < nLeaves; i++ )
        Vec_IntPush( vNodes, pLeaves[i] );
    Gia_ManPrintCollect_rec( p, pObj, vNodes );
    printf( "GIA logic cone for node %d:\n", Gia_ObjId(p, pObj) );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
        Gia_ObjPrint( p, pObj );
}

Here is the call graph for this function:

Gia_ManPrintCone2()

void Gia_ManPrintCone2	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

Definition at line 1618 of file giaUtil.c.

{
    Vec_Int_t * vNodes;
    int i;
    vNodes = Vec_IntAlloc( 100 );
    Gia_ManPrintCollect2_rec( p, pObj, vNodes );
    printf( "GIA logic cone for node %d:\n", Gia_ObjId(p, pObj) );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
        Gia_ObjPrint( p, pObj );
    Vec_IntFree( vNodes );
}

Here is the call graph for this function:

Gia_ManPrintConeMulti()

void Gia_ManPrintConeMulti	(	Gia_Man_t *	p,
		Vec_Int_t *	vObjs,
		Vec_Int_t *	vLeaves,
		Vec_Int_t *	vNodes )

Definition at line 1593 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Vec_IntClear( vNodes );
    Vec_IntAppend( vNodes, vLeaves );
    Gia_ManForEachObjVec( vObjs, p, pObj, i )
        Gia_ManPrintCollect_rec( p, pObj, vNodes );
    printf( "GIA logic cone for %d nodes:\n", Vec_IntSize(vObjs) );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
        Gia_ObjPrint( p, pObj );
}

Here is the call graph for this function:

Gia_ManRandom()

unsigned Gia_ManRandom

(

int

fReset

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates a sequence or random numbers.]

Description []

SideEffects []

SeeAlso [http://www.codeproject.com/KB/recipes/SimpleRNG.aspx]

Definition at line 49 of file giaUtil.c.

{
#ifdef _MSC_VER
    static unsigned int m_z = NUMBER1;
    static unsigned int m_w = NUMBER2;
#else
    static __thread unsigned int m_z = NUMBER1;
    static __thread unsigned int m_w = NUMBER2;
#endif    
    if ( fReset )
    {
        m_z = NUMBER1;
        m_w = NUMBER2;
    }
    m_z = 36969 * (m_z & 65535) + (m_z >> 16);
    m_w = 18000 * (m_w & 65535) + (m_w >> 16);
    return (m_z << 16) + m_w;
}

Gia_ManRandomInfo()

void Gia_ManRandomInfo	(	Vec_Ptr_t *	vInfo,
		int	iInputStart,
		int	iWordStart,
		int	iWordStop )

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

Synopsis [Creates random info for the primary inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 85 of file giaUtil.c.

{
    unsigned * pInfo;
    int i, w;
    Vec_PtrForEachEntryStart( unsigned *, vInfo, pInfo, i, iInputStart )
        for ( w = iWordStart; w < iWordStop; w++ )
            pInfo[w] = Gia_ManRandom(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManRandomW()

word Gia_ManRandomW

(

int

fReset

)

Definition at line 67 of file giaUtil.c.

{ 
    return ((word)Gia_ManRandom(fReset) << 32) | ((word)Gia_ManRandom(fReset) << 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManRequiredLevel()

Vec_Int_t * Gia_ManRequiredLevel

(

Gia_Man_t *

p

)

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

Synopsis [Compute required levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 702 of file giaUtil.c.

{
    Vec_Int_t * vRequired;
    Gia_Obj_t * pObj;
    int i, LevelMax = 0;
    vRequired = Gia_ManReverseLevel( p );
    Gia_ManForEachCi( p, pObj, i )
        LevelMax = Abc_MaxInt( LevelMax, Vec_IntEntry(vRequired, Gia_ObjId(p, pObj)) );
    Gia_ManForEachObj( p, pObj, i )
        Vec_IntWriteEntry( vRequired, i, LevelMax - Vec_IntEntry(vRequired, i) );
    return vRequired;
}

Here is the call graph for this function:

Gia_ManReverseLevel()

Vec_Int_t * Gia_ManReverseLevel

(

Gia_Man_t *

p

)

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

Synopsis [Compute reverse levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 658 of file giaUtil.c.

{
    Vec_Int_t * vLevelRev;
    Gia_Obj_t * pObj;
    int i;
    vLevelRev = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_ManForEachAndReverse( p, pObj, i )
    {
        int LevelR = Vec_IntEntry( vLevelRev, i );
        if ( Gia_ObjIsMux(p, pObj) )
        {
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId0(pObj, i), LevelR + 2 );
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId1(pObj, i), LevelR + 2 );
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId2(p, i), LevelR + 2 );
        }
        else if ( Gia_ObjIsXor(pObj) )
        {
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId0(pObj, i), LevelR + 2 );
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId1(pObj, i), LevelR + 2 );
        }
        else if ( Gia_ObjIsBuf(pObj) )
        {
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId0(pObj, i), LevelR );
        }
        else
        {
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId0(pObj, i), LevelR + 1 );
            Vec_IntUpdateEntry( vLevelRev, Gia_ObjFaninId1(pObj, i), LevelR + 1 );
        }
    }
    return vLevelRev;
}

Here is the caller graph for this function:

Gia_ManRingAdd()

void Gia_ManRingAdd	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vRes,
		Vec_Int_t *	vDists,
		int	Dist )

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

Synopsis [Collect distance info.]

Description []

SideEffects []

SeeAlso []

Definition at line 2446 of file giaUtil.c.

{
    if ( Gia_ObjIsTravIdCurrentId(p, iObj) )
        return;
    Gia_ObjSetTravIdCurrentId(p, iObj);
    Vec_IntWriteEntry( vDists, iObj, Dist );
    Vec_IntPush( vRes, iObj );
}

Here is the caller graph for this function:

Gia_ManSaveValue()

Vec_Int_t * Gia_ManSaveValue

(

Gia_Man_t *

p

)

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

Synopsis [Save/load value from file.]

Description []

SideEffects []

SeeAlso []

Definition at line 1831 of file giaUtil.c.

{
    Vec_Int_t * vValues;
    Gia_Obj_t * pObj;
    int i;
    vValues = Vec_IntAlloc( Gia_ManObjNum(p) );
    Gia_ManForEachObj( p, pObj, i )
        Vec_IntPush( vValues, pObj->Value );
    return vValues;
}

Gia_ManSetLevels()

int Gia_ManSetLevels	(	Gia_Man_t *	p,
		Vec_Int_t *	vCiLevels )

Definition at line 621 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    if ( vCiLevels == NULL )
        return Gia_ManLevelNum( p );
    assert( Vec_IntSize(vCiLevels) == Gia_ManCiNum(p) );
    Gia_ManCleanLevels( p, Gia_ManObjNum(p) );
    p->nLevels = 0;
    Gia_ManForEachCi( p, pObj, i )
    {
        Gia_ObjSetLevel( p, pObj, Vec_IntEntry(vCiLevels, i) );
        p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
    }
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            Gia_ObjSetGateLevel( p, pObj );
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjSetCoLevel( p, pObj );
        else continue;
        p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
    }
    return p->nLevels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSetMark0()

void Gia_ManSetMark0

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 237 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark0 = 1;
}

Here is the caller graph for this function:

Gia_ManSetMark1()

void Gia_ManSetMark1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 294 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark1 = 1;
}

Gia_ManSetPhase()

void Gia_ManSetPhase

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 420 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachObj( p, pObj, i )
        Gia_ObjSetPhase( p, pObj );
}

Here is the call graph for this function:

Gia_ManSetPhase1()

void Gia_ManSetPhase1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 450 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    Gia_ManForEachCi( p, pObj, i )
        pObj->fPhase = 1;
    Gia_ManForEachObj( p, pObj, i )
        if ( !Gia_ObjIsCi(pObj) )
            Gia_ObjSetPhase( p, pObj );
}

Here is the call graph for this function:

Gia_ManSetPhasePattern()

void Gia_ManSetPhasePattern	(	Gia_Man_t *	p,
		Vec_Int_t *	vCiValues )

Definition at line 427 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManCiNum(p) == Vec_IntSize(vCiValues) );
    Gia_ManForEachObj( p, pObj, i )
        if ( Gia_ObjIsCi(pObj) )
            pObj->fPhase = Vec_IntEntry( vCiValues, Gia_ObjCioId(pObj) );
        else
            Gia_ObjSetPhase( p, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManSumTotalOfSupportSizes()

int Gia_ManSumTotalOfSupportSizes

(

Gia_Man_t *

p

)

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

Synopsis [Computes sum total of support size of primary outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2570 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    Vec_Wec_t * vSupps = Vec_WecStart( Gia_ManObjNum(p) );
    int i, nResult = 0;
    for ( i = 0; i < Gia_ManCiNum(p); i++ )
        Vec_IntPush( Vec_WecEntry(vSupps, 1+i), i );
    Gia_ManForEachAnd( p, pObj, i )
        Vec_IntTwoMerge2( Vec_WecEntry(vSupps, Gia_ObjFaninId0(pObj, i)), Vec_WecEntry(vSupps, Gia_ObjFaninId1(pObj, i)), Vec_WecEntry(vSupps, i) ); 
    Gia_ManForEachCo( p, pObj, i )
        nResult += Vec_IntSize( Vec_WecEntry(vSupps, Gia_ObjFaninId0p(p, pObj)) );
    Vec_WecFree( vSupps );
    return nResult;
}

Gia_ManSumTotalOfSupportSizes2()

int Gia_ManSumTotalOfSupportSizes2

(

Gia_Man_t *

p

)

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

Synopsis [Computes sum total of support size of primary outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2596 of file giaUtil.c.

{
    Vec_Wrd_t * vSims = Vec_WrdStart( Gia_ManObjNum(p) );
    int r, nResult = 0, nRounds = (Gia_ManCiNum(p) + 63)/64;
    for ( r = 0; r < nRounds; r++ )
    {
        Gia_Obj_t * pObj;
        int i, Limit = r == nRounds-1 ? Gia_ManCiNum(p) % 64 : 64;
        for ( i = 0; i < Limit; i++ )
            Vec_WrdWriteEntry( vSims, 1+64*r+i, (word)1 << i );
        Gia_ManForEachAnd( p, pObj, i )
            Vec_WrdWriteEntry( vSims, i, Vec_WrdEntry(vSims, Gia_ObjFaninId0(pObj, i)) | Vec_WrdEntry(vSims, Gia_ObjFaninId1(pObj, i)) );
        Gia_ManForEachCo( p, pObj, i )
            nResult += Abc_TtCountOnes( Vec_WrdEntry(vSims, Gia_ObjFaninId0p(p, pObj)) );
        for ( i = 0; i < Limit; i++ )
            Vec_WrdWriteEntry( vSims, 1+64*r+i, 0 );
    }
    Vec_WrdFree( vSims );
    return nResult;
}

Gia_ManSwapPos()

void Gia_ManSwapPos	(	Gia_Man_t *	p,
		int	i )

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

Synopsis [Swaps PO number 0 with PO number i.]

Description []

SideEffects []

SeeAlso []

Definition at line 1808 of file giaUtil.c.

{
    int Lit0, LitI;
    assert( i >= 0 && i < Gia_ManPoNum(p) );
    if ( i == 0 )
        return;
    Lit0 = Gia_ObjFaninLit0p( p, Gia_ManPo(p, 0) );
    LitI = Gia_ObjFaninLit0p( p, Gia_ManPo(p, i) );
    Gia_ManPatchCoDriver( p, 0, LitI );
    Gia_ManPatchCoDriver( p, i, Lit0 );
}

Here is the caller graph for this function:

Gia_ManTestProblem()

void Gia_ManTestProblem

(

)

Definition at line 3250 of file giaUtil.c.

{
    unsigned Truth = 0xFE;
    int i, j, k, c, nIns = 3, nAux = 3;
    int nTotal = nIns + 1 + nAux;
    int nPairs = nTotal * (nTotal - 1) / 2;
    int nMints = (1 << (nIns+1));
    int M[64][100] = {{0}};
    float Value[64] = {0};
    float Solution[100] = {0};
    assert( nMints <= 64 );
    assert( nPairs <= 100 );
    // 7 nodes: 3 inputs + 1 output + 3 aux 
    // 7*6/2 = 21 pairs
    // 16 minterms
    for ( k = 0; k < nMints; k++ )
    {
        for ( i = c = 0; i < nTotal; i++ )
        for ( j = i+1; j < nTotal; j++ )    
        {
            int iVal = Gia_GetMValue( i, nIns, k, Truth );
            int jVal = Gia_GetMValue( j, nIns, k, Truth );
            M[k][c++] = iVal == jVal ? 1 : -1;
        }
        Value[k] = k < (1 << nIns) ? -1 : 1;
        assert( c == nPairs ); 
    }
 
    for ( k = 0; k < nMints; k++ )
    {
        for ( c = 0; c < nPairs; c++ )
           printf( "%2d ", M[k][c] );
        printf( "%3f\n", Value[k] );
    }
 
    // solve
    float Delta = 0.02;
    for ( i = 0; i < 100; i++ )
    {
        float Error = 0;
        for ( k = 0; k < nMints; k++ )
            Error += Value[k] > 0 ? Value[k] : -Value[k];
        printf( "Round %3d : Error = %5f    ", i, Error );
        for ( c = 0; c < nPairs; c++ )
            printf( "%2f ", Solution[c] );
        printf( "\n" );
 
        //if ( Error < 1 )
        //   Delta /= 10;
 
        for ( c = 0; c < nPairs; c++ )
        {
            int Count = 0;
            for ( k = 0; k < nMints; k++ )
               if ( (M[k][c] > 0 && Value[k] > 0) || (M[k][c] < 0 && Value[k] < 0) )
                   Count++;
               else
                   Count--;
            if ( Count == 0 )
               continue;
            printf( "Count = %3d  ", Count );
            if ( Count > 0 )
            {
                printf( "Increasing %d by %f\n", c, Delta );
                Solution[c] += Delta;
                for ( k = 0; k < nMints; k++ )
                    if ( M[k][c] > 0 )
                        Value[k] -= Delta;
                    else
                        Value[k] -= Delta;
            }
            else
            {
                printf( "Reducing %d by %f\n", c, Delta );
                Solution[c] -= Delta;
                for ( k = 0; k < nMints; k++ )
                    if ( M[k][c] > 0 )
                        Value[k] += Delta;
                    else
                        Value[k] += Delta;
            }            
        }
    }
}

Here is the call graph for this function:

Gia_ManTransformCond()

Gia_Man_t * Gia_ManTransformCond

(

Gia_Man_t *

p

)

Definition at line 3101 of file giaUtil.c.

{
    extern void Gia_ManResubPair( Vec_Wrd_t * vOn, Vec_Wrd_t * vOff, int nWords, int nIns );
    abctime clk = Abc_Clock();
    Vec_Wrd_t * vSims;
    Vec_Wrd_t * vSim[4];
    Vec_Wrd_t * vInt[6];
    int i;
    for ( i = 0; i < Gia_ManCoNum(p); i++ )
    {
        vSims = Gia_ManDetectSims( p, i, 1 );
        if ( i >= Gia_ManCoNum(p)-4 )
            vSim[i-(Gia_ManCoNum(p)-4)] = vSims;
        else
            Vec_WrdFreeP( &vSims );
        //Vec_PtrPush( vAll, vSims );
    }
    vInt[0] = Vec_WrdInterleave( vSim[0], vSim[1], 1, Gia_ManCiNum(p) );
    vInt[1] = Vec_WrdInterleave( vSim[0], vSim[2], 1, Gia_ManCiNum(p) );
    vInt[2] = Vec_WrdInterleave( vSim[0], vSim[3], 1, Gia_ManCiNum(p) );
    vInt[3] = Vec_WrdInterleave( vSim[1], vSim[2], 1, Gia_ManCiNum(p) );
    vInt[4] = Vec_WrdInterleave( vSim[1], vSim[3], 1, Gia_ManCiNum(p) );
    vInt[5] = Vec_WrdInterleave( vSim[2], vSim[3], 1, Gia_ManCiNum(p) );
 
    Gia_ManResubPair( vInt[0], vInt[5], 2, Gia_ManCiNum(p) );
    Gia_ManResubPair( vInt[1], vInt[4], 2, Gia_ManCiNum(p) );
    Gia_ManResubPair( vInt[2], vInt[3], 2, Gia_ManCiNum(p) );
 
    Gia_ManResubPair( vInt[5], vInt[0], 2, Gia_ManCiNum(p) );
    Gia_ManResubPair( vInt[4], vInt[1], 2, Gia_ManCiNum(p) );
    Gia_ManResubPair( vInt[3], vInt[2], 2, Gia_ManCiNum(p) );
 
/*
    for ( i = 0; i < 4; i++ )
    for ( k = i+1; k < 4; k++ )
        Gia_ManResubPair( vSim[i], vSim[k], 1, Gia_ManCiNum(p) );
*/
    Abc_PrintTime( 0, "Time", Abc_Clock() - clk );
    return NULL;
}

Here is the call graph for this function:

Gia_ManTransformCond2()

Gia_Man_t * Gia_ManTransformCond2

(

Gia_Man_t *

p

)

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

Synopsis [Transform flops.]

Description []

SideEffects []

SeeAlso []

Definition at line 2996 of file giaUtil.c.

{
    int fVerbose = 1;
    abctime clk = Abc_Clock();
    Gia_Man_t * pNew, * pTemp; 
    Gia_Obj_t * pObjPi, * pObjRi, * pObjRo; 
    int i, n, iTempLit, iLits[2];
    assert( Gia_ManRegNum(p) > 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManFillValue(p);
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObjPi, i )
        pObjPi->Value = Gia_ManAppendCi( pNew );
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachRi( p, pObjRi, i )
    {
        //if ( (i - Gia_ManPoNum(p)) % 8 != 0 )
        //    continue;
        pObjRo = Gia_ObjRiToRo(p, pObjRi);
        iTempLit = pObjRo->Value;
        for ( n = 0; n < 2; n++ )
        {
            pObjRo->Value = n;
            Gia_ManIncrementTravId( p );
            Gia_ManConvertSupp_rec( pNew, p, Gia_ObjFanin0(pObjRi) );
            iLits[n] = Gia_ObjFanin0Copy(pObjRi);
        }
        pObjRo->Value = iTempLit;
        Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ManHashAnd( pNew, iLits[1], Abc_LitNot(iLits[0]) )) );
        Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ManHashAnd( pNew, iLits[0], Abc_LitNot(iLits[1]) )) );
    }
    Gia_ManHashStop( pNew );
    //Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    if ( fVerbose )
        printf( "Created %d outputs.  ", Gia_ManPoNum(pNew) );
    if ( fVerbose )
        Abc_PrintTime( 0, "Time", Abc_Clock() - clk );
    return pNew;
}

Here is the call graph for this function:

Gia_ManUpdateCopy()

void Gia_ManUpdateCopy	(	Vec_Int_t *	vCopy,
		Gia_Man_t *	p )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2352 of file giaUtil.c.

{
    Gia_Obj_t * pObj;
    int i, iLit;
    Vec_IntForEachEntry( vCopy, iLit, i )
    {
        if ( iLit == -1 )
            continue;
        pObj = Gia_ManObj( p, Abc_Lit2Var(iLit) );
        if ( !~pObj->Value )
            Vec_IntWriteEntry( vCopy, i, -1 );
        else
            Vec_IntWriteEntry( vCopy, i, Abc_LitNotCond(pObj->Value, Abc_LitIsCompl(iLit)) );
    }
}

Here is the caller graph for this function:

Gia_ManWindowCheckTopoError()

int Gia_ManWindowCheckTopoError	(	Gia_Man_t *	p,
		Vec_Int_t *	vIns,
		Vec_Int_t *	vOuts )

Definition at line 3360 of file giaUtil.c.

{
    Gia_Obj_t * pObj; int i, fError = 0;
    // outputs should be internal nodes
    Gia_ManForEachObjVec( vOuts, p, pObj, i )
        assert(Gia_ObjIsAnd(pObj));
    // mark outputs
    Gia_ManIncrementTravId( p );
    Gia_ManForEachObjVec( vOuts, p, pObj, i )
        Gia_ObjSetTravIdCurrent(p, pObj);
    // start from inputs and make sure we do not reach any of the outputs
    Gia_ManIncrementTravId( p );
    Gia_ManForEachObjVec( vIns, p, pObj, i )
        fError |= Gia_ManWindowCheckTopoError_rec(p, pObj);
    return fError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManWindowCheckTopoError_rec()

int Gia_ManWindowCheckTopoError_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

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

Synopsis [Returns 1 if this window has a topo error (forward path from an output to an input).]

Description []

SideEffects []

SeeAlso []

Definition at line 3346 of file giaUtil.c.

{
    if ( !Gia_ObjIsAnd(pObj) )
        return 0;
    if ( Gia_ObjIsTravIdPrevious(p, pObj) )
        return 1; // there is an error
    if ( Gia_ObjIsTravIdCurrent(p, pObj) )
        return 0; // there is no error; visited this node before
    Gia_ObjSetTravIdPrevious(p, pObj);
    if ( Gia_ManWindowCheckTopoError_rec(p, Gia_ObjFanin0(pObj)) || Gia_ManWindowCheckTopoError_rec(p, Gia_ObjFanin1(pObj)) )
        return 1;
    Gia_ObjSetTravIdCurrent(p, pObj);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ManWriteResub()

void Gia_ManWriteResub	(	Gia_Man_t *	p,
		char *	pFileName )

Definition at line 3161 of file giaUtil.c.

{
    FILE * pFile = fopen( pFileName, "wb" ); 
    if ( pFile == NULL )
        printf( "Cannot open output file \"%s\".\n", pFileName );
    else
    {
        Vec_Wrd_t * vSimsPi = Vec_WrdStartTruthTables( Gia_ManCiNum(p) );
        Vec_Wrd_t * vSimsPo = Gia_ManSimPatSimOut( p, vSimsPi, 1 );
        int i, k, nWords = Vec_WrdSize(vSimsPi) / Gia_ManCiNum(p);
        word * pTemp = ABC_ALLOC( word, nWords );
        fprintf( pFile, "%d %d %d %d\n", Gia_ManCiNum(p), 0, Gia_ManCoNum(p), 1 << Gia_ManCiNum(p) );
        for ( i = 0; i < Gia_ManCiNum(p); i++ )
            Abc_TtPrintBinary1( pFile, Vec_WrdEntryP(vSimsPi, i*nWords), Gia_ManCiNum(p) ), fprintf(pFile, "\n");
        for ( i = 0; i < (1 << Gia_ManCoNum(p)); i++ )
        {
            Abc_TtFill( pTemp, nWords );
            for ( k = 0; k < Gia_ManCoNum(p); k++ )
                Abc_TtAndCompl( pTemp, pTemp, 0, Vec_WrdEntryP(vSimsPo, k*nWords), !((i>>k)&1), nWords );
            Abc_TtPrintBinary1( pFile, pTemp, Gia_ManCiNum(p) ), fprintf(pFile, "\n");
        }
        ABC_FREE( pTemp );
        fclose( pFile );
        Vec_WrdFree( vSimsPi );
        Vec_WrdFree( vSimsPo );
        printf( "Finished writing resub file \"%s\".\n", pFileName );
        Gia_ManWriteSol( p, pFileName );
    }
}

Here is the call graph for this function:

Gia_ManWriteSol()

void Gia_ManWriteSol	(	Gia_Man_t *	p,
		char *	pFileName )

Definition at line 3141 of file giaUtil.c.

{
    char * pBasicName = Extra_FileNameGeneric( pFileName ); 
    char * pFileName2 = Abc_UtilStrsavTwo( pBasicName, ".sol" ); 
    FILE * pFile = fopen( pFileName2, "wb" );
    ABC_FREE( pBasicName );
    if ( pFile == NULL )
        printf( "Cannot open output file \"%s\".\n", pFileName2 );
    else
    {
        Gia_Obj_t * pObj; int i;
        Gia_ManForEachAnd( p, pObj, i )
            fprintf( pFile, "%d %d ", Gia_ObjFaninLit0(pObj, i), Gia_ObjFaninLit1(pObj, i) );
        Gia_ManForEachCo( p, pObj, i )
            fprintf( pFile, "%d %d ", Gia_ObjFaninLit0p(p, pObj), Gia_ObjFaninLit0p(p, pObj) );
        fclose( pFile );   
        printf( "Finished writing solution file \"%s\".\n", pFileName2 );
    }
    ABC_FREE( pFileName2 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeCollect_rec()

void Gia_NodeCollect_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode,
		Vec_Int_t *	vSupp )

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

Synopsis [Returns the number of internal nodes in the MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 1265 of file giaUtil.c.

{
    if ( Gia_ObjIsTravIdCurrent(p, pNode) )
        return;
    Gia_ObjSetTravIdCurrent(p, pNode);
    if ( Gia_ObjRefNum(p, pNode) || Gia_ObjIsCi(pNode) )
    {
        Vec_IntPush( vSupp, Gia_ObjId(p, pNode) );
        return;
    }
    assert( Gia_ObjIsAnd(pNode) );
    Gia_NodeCollect_rec( p, Gia_ObjFanin0(pNode), vSupp );
    Gia_NodeCollect_rec( p, Gia_ObjFanin1(pNode), vSupp );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeDeref_rec()

int Gia_NodeDeref_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode )

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

Synopsis [Dereferences the node's MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 1155 of file giaUtil.c.

{
    Gia_Obj_t * pFanin;
    int Counter = 0;
    if ( Gia_ObjIsCi(pNode) )
        return 0;
    assert( Gia_ObjIsAnd(pNode) );
    pFanin = Gia_ObjFanin0(pNode);
    assert( Gia_ObjRefNum(p, pFanin) > 0 );
    if ( Gia_ObjRefDec(p, pFanin) == 0 )
        Counter += Gia_NodeDeref_rec( p, pFanin );
    pFanin = Gia_ObjFanin1(pNode);
    assert( Gia_ObjRefNum(p, pFanin) > 0 );
    if ( Gia_ObjRefDec(p, pFanin) == 0 )
        Counter += Gia_NodeDeref_rec( p, pFanin );
    return Counter + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeMffcMapping()

int Gia_NodeMffcMapping

(

Gia_Man_t *

p

)

Definition at line 1324 of file giaUtil.c.

{
    int i, Id, Count = 0;
    int * pRefsOld;
    Vec_Int_t * vMapping, * vSupp = Vec_IntAlloc( 100 );
    vMapping = Vec_IntAlloc( 2 * Gia_ManObjNum(p) );
    Vec_IntFill( vMapping, Gia_ManObjNum(p), 0 );
    pRefsOld = p->pRefs; p->pRefs = NULL;
    Gia_ManCreateRefs( p ); 
    Gia_ManForEachCoDriverId( p, Id, i )
        Count += Gia_NodeMffcMapping_rec( p, Id, vMapping, vSupp );
    p->pRefs = pRefsOld;
    Vec_IntFree( vSupp );
    p->vMapping = vMapping;
    //printf( "Mapping is %.2fx larger than AIG manager.\n", 1.0*Vec_IntSize(vMapping)/Gia_ManObjNum(p) );
    return Count;
}

Here is the call graph for this function:

Gia_NodeMffcMapping_rec()

int Gia_NodeMffcMapping_rec	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vMapping,
		Vec_Int_t *	vSupp )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1306 of file giaUtil.c.

{
    Gia_Obj_t * pObj; int i, iNode, Count = 1;
    if ( !iObj || Vec_IntEntry(vMapping, iObj) )
        return 0;
    pObj = Gia_ManObj( p, iObj );
    if ( Gia_ObjIsCi(pObj) )
        return 0;
    Gia_NodeMffcSizeSupp( p, pObj, vSupp );
    Vec_IntSort( vSupp, 0 );
    Vec_IntWriteEntry( vMapping, iObj, Vec_IntSize(vMapping) );
    Vec_IntPush( vMapping, Vec_IntSize(vSupp) );
    Vec_IntAppend( vMapping, vSupp );
    Vec_IntPush( vMapping, iObj );
    Vec_IntForEachEntry( vSupp, iNode, i )
        Count += Gia_NodeMffcMapping_rec( p, iNode, vMapping, vSupp );
    return Count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeMffcSize()

int Gia_NodeMffcSize	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode )

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

Synopsis [Returns the number of internal nodes in the MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 1230 of file giaUtil.c.

{
    int ConeSize1, ConeSize2;
    assert( !Gia_IsComplement(pNode) );
    assert( Gia_ObjIsCand(pNode) );
    ConeSize1 = Gia_NodeDeref_rec( p, pNode );
    ConeSize2 = Gia_NodeRef_rec( p, pNode, 0 );
    assert( ConeSize1 == ConeSize2 );
    assert( ConeSize1 >= 0 );
    return ConeSize1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeMffcSizeMark()

int Gia_NodeMffcSizeMark	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode )

Definition at line 1241 of file giaUtil.c.

{
    int ConeSize1, ConeSize2;
    assert( !Gia_IsComplement(pNode) );
    assert( Gia_ObjIsCand(pNode) );
    ConeSize1 = Gia_NodeDeref_rec( p, pNode );
    Gia_ManIncrementTravId( p );
    ConeSize2 = Gia_NodeRef_rec( p, pNode, 1 );
    assert( ConeSize1 == ConeSize2 );
    assert( ConeSize1 >= 0 );
    return ConeSize1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeMffcSizeSupp()

int Gia_NodeMffcSizeSupp	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode,
		Vec_Int_t *	vSupp )

Definition at line 1279 of file giaUtil.c.

{
    int ConeSize1, ConeSize2;
    assert( !Gia_IsComplement(pNode) );
    assert( Gia_ObjIsAnd(pNode) );
    Vec_IntClear( vSupp );
    Gia_ManIncrementTravId( p );
    ConeSize1 = Gia_NodeDeref_rec( p, pNode );
    Gia_NodeCollect_rec( p, Gia_ObjFanin0(pNode), vSupp );
    Gia_NodeCollect_rec( p, Gia_ObjFanin1(pNode), vSupp );
    ConeSize2 = Gia_NodeRef_rec( p, pNode, 0 );
    assert( ConeSize1 == ConeSize2 );
    assert( ConeSize1 >= 0 );
    return ConeSize1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_NodeRef_rec()

int Gia_NodeRef_rec	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode,
		int	fMark )

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

Synopsis [References the node's MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 1184 of file giaUtil.c.

{
    Gia_Obj_t * pFanin;
    int Counter = 0;
    if ( Gia_ObjIsCi(pNode) )
        return 0;
    assert( Gia_ObjIsAnd(pNode) );
    if ( fMark ) Gia_ObjSetTravIdCurrent(p, pNode);
    pFanin = Gia_ObjFanin0(pNode);
    if ( Gia_ObjRefInc(p, pFanin) == 0 )
        Counter += Gia_NodeRef_rec( p, pFanin, fMark );
    pFanin = Gia_ObjFanin1(pNode);
    if ( Gia_ObjRefInc(p, pFanin) == 0 )
        Counter += Gia_NodeRef_rec( p, pFanin, fMark );
    return Counter + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ObjIsMuxType()

int Gia_ObjIsMuxType

(

Gia_Obj_t *

pNode

)

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

Synopsis [Returns 1 if the node is the root of MUX or EXOR/NEXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 982 of file giaUtil.c.

{
    Gia_Obj_t * pNode0, * pNode1;
    // check that the node is regular
    assert( !Gia_IsComplement(pNode) );
    // if the node is not AND, this is not MUX
    if ( !Gia_ObjIsAnd(pNode) || Gia_ObjIsBuf(pNode) )
        return 0;
    // if the children are not complemented, this is not MUX
    if ( !Gia_ObjFaninC0(pNode) || !Gia_ObjFaninC1(pNode) )
        return 0;
    // get children
    pNode0 = Gia_ObjFanin0(pNode);
    pNode1 = Gia_ObjFanin1(pNode);
    // if the children are not ANDs, this is not MUX
    if ( !Gia_ObjIsAnd(pNode0) || !Gia_ObjIsAnd(pNode1) )
        return 0;
    // otherwise the node is MUX iff it has a pair of equal grandchildren
    return (Gia_ObjFanin0(pNode0) == Gia_ObjFanin0(pNode1) && (Gia_ObjFaninC0(pNode0) ^ Gia_ObjFaninC0(pNode1))) || 
           (Gia_ObjFanin0(pNode0) == Gia_ObjFanin1(pNode1) && (Gia_ObjFaninC0(pNode0) ^ Gia_ObjFaninC1(pNode1))) ||
           (Gia_ObjFanin1(pNode0) == Gia_ObjFanin0(pNode1) && (Gia_ObjFaninC1(pNode0) ^ Gia_ObjFaninC0(pNode1))) ||
           (Gia_ObjFanin1(pNode0) == Gia_ObjFanin1(pNode1) && (Gia_ObjFaninC1(pNode0) ^ Gia_ObjFaninC1(pNode1)));
}

Here is the caller graph for this function:

Gia_ObjPrint()

void Gia_ObjPrint	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

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

Synopsis [Verbose printing of the AIG node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1456 of file giaUtil.c.

{
    if ( pObj == NULL )
    {
        printf( "Object is NULL." );
        return;
    }
    if ( Gia_IsComplement(pObj) )
    {
        printf( "Compl " );
        pObj = Gia_Not(pObj);
    }
    assert( !Gia_IsComplement(pObj) );
    printf( "Obj %4d : ", Gia_ObjId(p, pObj) );
    if ( Gia_ObjIsConst0(pObj) )
        printf( "constant 0" );
    else if ( Gia_ObjIsPi(p, pObj) )
        printf( "PI" );
    else if ( Gia_ObjIsPo(p, pObj) )
        printf( "PO( %4d%s )", Gia_ObjFaninId0p(p, pObj), (Gia_ObjFaninC0(pObj)? "\'" : " ") );
    else if ( Gia_ObjIsCi(pObj) )
        printf( "RO( %4d%s )", Gia_ObjFaninId0p(p, Gia_ObjRoToRi(p, pObj)), (Gia_ObjFaninC0(Gia_ObjRoToRi(p, pObj))? "\'" : " ") );
    else if ( Gia_ObjIsCo(pObj) )
        printf( "RI( %4d%s )", Gia_ObjFaninId0p(p, pObj), (Gia_ObjFaninC0(pObj)? "\'" : " ") );
//    else if ( Gia_ObjIsBuf(pObj) )
//        printf( "BUF( %d%s )", Gia_ObjFaninId0p(p, pObj), (Gia_ObjFaninC0(pObj)? "\'" : " ") );
    else if ( Gia_ObjIsXor(pObj) )
        printf( "XOR( %4d%s, %4d%s )", 
            Gia_ObjFaninId0p(p, pObj), (Gia_ObjFaninC0(pObj)? "\'" : " "), 
            Gia_ObjFaninId1p(p, pObj), (Gia_ObjFaninC1(pObj)? "\'" : " ") );
    else if ( Gia_ObjIsMuxId(p, Gia_ObjId(p, pObj)) )
        printf( "MUX( %4d%s, %4d%s, %4d%s )", 
            Gia_ObjFaninId2p(p, pObj), (Gia_ObjFaninC2(p, pObj)? "\'" : " "), 
            Gia_ObjFaninId1p(p, pObj), (Gia_ObjFaninC1(pObj)? "\'" : " "), 
            Gia_ObjFaninId0p(p, pObj), (Gia_ObjFaninC0(pObj)? "\'" : " ") );
    else
        printf( "AND( %4d%s, %4d%s )", 
            Gia_ObjFaninId0p(p, pObj), (Gia_ObjFaninC0(pObj)? "\'" : " "), 
            Gia_ObjFaninId1p(p, pObj), (Gia_ObjFaninC1(pObj)? "\'" : " ") );
    if ( p->pRefs )
        printf( " (refs = %3d)", Gia_ObjRefNum(p, pObj) );
    if ( pObj->fMark0 )
        printf( " mark0" );
    if ( pObj->fMark1 )
        printf( " mark1" );
    if ( Gia_ManHasMapping(p) && Gia_ObjIsLut(p, Gia_ObjId(p, pObj)) )
    {
        int i, iFan;
        printf( " Cut = { " );
        Gia_LutForEachFanin( p, Gia_ObjId(p, pObj), iFan, i )
            printf( "%d ", iFan );
        printf( "}" );
    }
    if ( Gia_ManHasMapping2(p) && Gia_ObjIsLut2(p, Gia_ObjId(p, pObj)) )
    {
        int i, iFan;
        printf( " Cut = { " );
        Gia_LutForEachFanin2( p, Gia_ObjId(p, pObj), iFan, i )
            printf( "%d ", iFan );
        printf( "}" );
    }
    printf( "\n" );
/*
    if ( p->pRefs )
    {
        Gia_Obj_t * pFanout;
        int i;
        int iFan = -1; // Suppress "might be used uninitialized"
        printf( "\nFanouts:\n" );
        Gia_ObjForEachFanout( p, pObj, pFanout, iFan, i )
        {
            printf( "    " );
            printf( "Node %4d : ", Gia_ObjId(pFanout) );
            if ( Gia_ObjIsPo(pFanout) )
                printf( "PO( %4d%s )", Gia_ObjFanin0(pFanout)->Id, (Gia_ObjFaninC0(pFanout)? "\'" : " ") );
            else if ( Gia_ObjIsBuf(pFanout) )
                printf( "BUF( %d%s )", Gia_ObjFanin0(pFanout)->Id, (Gia_ObjFaninC0(pFanout)? "\'" : " ") );
            else
                printf( "AND( %4d%s, %4d%s )", 
                    Gia_ObjFanin0(pFanout)->Id, (Gia_ObjFaninC0(pFanout)? "\'" : " "), 
                    Gia_ObjFanin1(pFanout)->Id, (Gia_ObjFaninC1(pFanout)? "\'" : " ") );
            printf( "\n" );
        }
        return;
    }
*/
}

Here is the caller graph for this function:

Gia_ObjRecognizeExor()

int Gia_ObjRecognizeExor	(	Gia_Obj_t *	pObj,
		Gia_Obj_t **	ppFan0,
		Gia_Obj_t **	ppFan1 )

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

Synopsis [Recognizes what nodes are inputs of the EXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 1018 of file giaUtil.c.

{
    Gia_Obj_t * p0, * p1;
    assert( !Gia_IsComplement(pObj) );
    if ( !Gia_ObjIsAnd(pObj) || Gia_ObjIsBuf(pObj) )
        return 0;
    assert( Gia_ObjIsAnd(pObj) );
    p0 = Gia_ObjChild0(pObj);
    p1 = Gia_ObjChild1(pObj);
    if ( !Gia_IsComplement(p0) || !Gia_IsComplement(p1) )
        return 0;
    p0 = Gia_Regular(p0);
    p1 = Gia_Regular(p1);
    if ( !Gia_ObjIsAnd(p0) || !Gia_ObjIsAnd(p1) )
        return 0;
    if ( Gia_ObjFanin0(p0) != Gia_ObjFanin0(p1) || Gia_ObjFanin1(p0) != Gia_ObjFanin1(p1) )
        return 0;
    if ( Gia_ObjFaninC0(p0) == Gia_ObjFaninC0(p1) || Gia_ObjFaninC1(p0) == Gia_ObjFaninC1(p1) )
        return 0;
    if ( ppFan0 ) *ppFan0 = Gia_ObjChild0(p0);
    if ( ppFan1 ) *ppFan1 = Gia_ObjChild1(p0);
    return 1;
}

Here is the caller graph for this function:

Gia_ObjRecognizeMux()

Gia_Obj_t * Gia_ObjRecognizeMux	(	Gia_Obj_t *	pNode,
		Gia_Obj_t **	ppNodeT,
		Gia_Obj_t **	ppNodeE )

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

Synopsis [Recognizes what nodes are control and data inputs of a MUX.]

Description [If the node is a MUX, returns the control variable C. Assigns nodes T and E to be the then and else variables of the MUX. Node C is never complemented. Nodes T and E can be complemented. This function also recognizes EXOR/NEXOR gates as MUXes.]

SideEffects []

SeeAlso []

Definition at line 1056 of file giaUtil.c.

{
    Gia_Obj_t * pNode0, * pNode1;
    assert( !Gia_IsComplement(pNode) );
    assert( Gia_ObjIsMuxType(pNode) );
    // get children
    pNode0 = Gia_ObjFanin0(pNode);
    pNode1 = Gia_ObjFanin1(pNode);
 
    // find the control variable
    if ( Gia_ObjFanin1(pNode0) == Gia_ObjFanin1(pNode1) && (Gia_ObjFaninC1(pNode0) ^ Gia_ObjFaninC1(pNode1)) )
    {
//        if ( FrGia_IsComplement(pNode1->p2) )
        if ( Gia_ObjFaninC1(pNode0) )
        { // pNode2->p2 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild0(pNode1));//pNode2->p1);
            *ppNodeE = Gia_Not(Gia_ObjChild0(pNode0));//pNode1->p1);
            return Gia_ObjChild1(pNode1);//pNode2->p2;
        }
        else
        { // pNode1->p2 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild0(pNode0));//pNode1->p1);
            *ppNodeE = Gia_Not(Gia_ObjChild0(pNode1));//pNode2->p1);
            return Gia_ObjChild1(pNode0);//pNode1->p2;
        }
    }
    else if ( Gia_ObjFanin0(pNode0) == Gia_ObjFanin0(pNode1) && (Gia_ObjFaninC0(pNode0) ^ Gia_ObjFaninC0(pNode1)) )
    {
//        if ( FrGia_IsComplement(pNode1->p1) )
        if ( Gia_ObjFaninC0(pNode0) )
        { // pNode2->p1 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild1(pNode1));//pNode2->p2);
            *ppNodeE = Gia_Not(Gia_ObjChild1(pNode0));//pNode1->p2);
            return Gia_ObjChild0(pNode1);//pNode2->p1;
        }
        else
        { // pNode1->p1 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild1(pNode0));//pNode1->p2);
            *ppNodeE = Gia_Not(Gia_ObjChild1(pNode1));//pNode2->p2);
            return Gia_ObjChild0(pNode0);//pNode1->p1;
        }
    }
    else if ( Gia_ObjFanin0(pNode0) == Gia_ObjFanin1(pNode1) && (Gia_ObjFaninC0(pNode0) ^ Gia_ObjFaninC1(pNode1)) )
    {
//        if ( FrGia_IsComplement(pNode1->p1) )
        if ( Gia_ObjFaninC0(pNode0) )
        { // pNode2->p2 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild0(pNode1));//pNode2->p1);
            *ppNodeE = Gia_Not(Gia_ObjChild1(pNode0));//pNode1->p2);
            return Gia_ObjChild1(pNode1);//pNode2->p2;
        }
        else
        { // pNode1->p1 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild1(pNode0));//pNode1->p2);
            *ppNodeE = Gia_Not(Gia_ObjChild0(pNode1));//pNode2->p1);
            return Gia_ObjChild0(pNode0);//pNode1->p1;
        }
    }
    else if ( Gia_ObjFanin1(pNode0) == Gia_ObjFanin0(pNode1) && (Gia_ObjFaninC1(pNode0) ^ Gia_ObjFaninC0(pNode1)) )
    {
//        if ( FrGia_IsComplement(pNode1->p2) )
        if ( Gia_ObjFaninC1(pNode0) )
        { // pNode2->p1 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild1(pNode1));//pNode2->p2);
            *ppNodeE = Gia_Not(Gia_ObjChild0(pNode0));//pNode1->p1);
            return Gia_ObjChild0(pNode1);//pNode2->p1;
        }
        else
        { // pNode1->p2 is positive phase of C
            *ppNodeT = Gia_Not(Gia_ObjChild0(pNode0));//pNode1->p1);
            *ppNodeE = Gia_Not(Gia_ObjChild1(pNode1));//pNode2->p2);
            return Gia_ObjChild1(pNode0);//pNode1->p2;
        }
    }
    assert( 0 ); // this is not MUX
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ObjRecognizeMuxLits()

int Gia_ObjRecognizeMuxLits	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode,
		int *	iLitT,
		int *	iLitE )

Definition at line 1133 of file giaUtil.c.

{
    Gia_Obj_t * pNodeT, * pNodeE;
    Gia_Obj_t * pCtrl = Gia_ObjRecognizeMux( pNode, &pNodeT, &pNodeE );
    assert( pCtrl != NULL );
    *iLitT = Gia_Obj2Lit( p, pNodeT );
    *iLitE = Gia_Obj2Lit( p, pNodeE );
    return Gia_Obj2Lit( p, pCtrl );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gia_ObjSetPhase()

void Gia_ObjSetPhase	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

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

Synopsis [Sets the phase of one object.]

Description []

SideEffects []

SeeAlso []

Definition at line 387 of file giaUtil.c.

{
    if ( Gia_ObjIsAnd(pObj) )
    {
        int fPhase0 = Gia_ObjPhase(Gia_ObjFanin0(pObj)) ^ Gia_ObjFaninC0(pObj);
        int fPhase1 = Gia_ObjPhase(Gia_ObjFanin1(pObj)) ^ Gia_ObjFaninC1(pObj);
        if ( Gia_ObjIsMux(p, pObj) )
        {
            int fPhase2 = Gia_ObjPhase(Gia_ObjFanin2(p, pObj)) ^ Gia_ObjFaninC2(p, pObj);
            pObj->fPhase = (fPhase2 && fPhase1) || (!fPhase2 && fPhase0);
        }
        else if ( Gia_ObjIsXor(pObj) )
            pObj->fPhase = fPhase0 ^ fPhase1;
        else
            pObj->fPhase = fPhase0 & fPhase1;
    }
    else if ( Gia_ObjIsCo(pObj) )
        pObj->fPhase = (Gia_ObjPhase(Gia_ObjFanin0(pObj)) ^ Gia_ObjFaninC0(pObj));
    else
        pObj->fPhase = 0;
}

Here is the caller graph for this function:

Gia_TimeStamp()

char * Gia_TimeStamp

(

)

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

Synopsis [Returns the time stamp.]

Description [The file should be closed.]

SideEffects []

SeeAlso []

Definition at line 106 of file giaUtil.c.

{
    static char Buffer[100];
    char * TimeStamp;
    time_t ltime;
    // get the current time
    time( &ltime );
    TimeStamp = asctime( localtime( &ltime ) );
    TimeStamp[ strlen(TimeStamp) - 1 ] = 0;
    strcpy( Buffer, TimeStamp );
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Vec_WrdInterleave()

Vec_Wrd_t * Vec_WrdInterleave	(	Vec_Wrd_t *	p1,
		Vec_Wrd_t *	p2,
		int	nWords,
		int	nIns )

Definition at line 3086 of file giaUtil.c.

{
    Vec_Wrd_t * p = Vec_WrdAlloc( Vec_WrdSize(p1)+Vec_WrdSize(p2) );
    int i, k;
    assert( Vec_WrdSize(p1) == nWords*nIns );
    assert( Vec_WrdSize(p2) == nWords*nIns );
    for ( i = 0; i < nIns; i++ )
    {
        for ( k = 0; k < nWords; k++ )
            Vec_WrdPush( p, Vec_WrdEntry(p1, i*nWords+k) );
        for ( k = 0; k < nWords; k++ )
            Vec_WrdPush( p, Vec_WrdEntry(p2, i*nWords+k) );
    }
    return p;
}

Here is the caller graph for this function: