#include "gia.h"

Include dependency graph for giaGlitch.c:

Classes
struct	Gli_Obj_t_

struct	Gli_Man_t_

Macros
#define	Gli_ManForEachObj(p, pObj, i)

#define	Gli_ManForEachNode(p, pObj, i)

#define	Gli_ManForEachEntry(vVec, p, pObj, i)

#define	Gli_ManForEachCi(p, pObj, i)

#define	Gli_ManForEachCo(p, pObj, i)

#define	Gli_ManForEachPi(p, pObj, i)

#define	Gli_ManForEachPo(p, pObj, i)

#define	Gli_ManForEachRo(p, pObj, i)

#define	Gli_ManForEachRi(p, pObj, i)

#define	Gli_ManForEachRiRo(p, pObjRi, pObjRo, i)

#define	Gli_ObjForEachFanin(pObj, pNext, i)

#define	Gli_ObjForEachFanout(pObj, pNext, i)

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Gli_Obj_t_	Gli_Obj_t
	DECLARATIONS ///.

typedef struct Gli_Man_t_	Gli_Man_t

Functions
Gli_Man_t *	Gli_ManAlloc (int nObjs, int nRegs, int nFanioPairs)
	FUNCTION DEFINITIONS ///.

void	Gli_ManStop (Gli_Man_t *p)

void	Gli_ManPrintObjects (Gli_Man_t *p)

void	Gli_ManFinalize (Gli_Man_t *p)

void	Gli_ObjAddFanin (Gli_Obj_t pObj, Gli_Obj_t pFanin)

Gli_Obj_t *	Gli_ObjAlloc (Gli_Man_t *p, int nFanins, int nFanouts)

int	Gli_ManCreateCi (Gli_Man_t *p, int nFanouts)

int	Gli_ManCreateCo (Gli_Man_t *p, int iFanin)

int	Gli_ManCreateNode (Gli_Man_t p, Vec_Int_t vFanins, int nFanouts, word *pGateTruth)

int	Gli_ObjNumSwitches (Gli_Man_t *p, int iNode)

int	Gli_ObjNumGlitches (Gli_Man_t *p, int iNode)

void	Gli_ManSetPiRandom (Gli_Man_t *p, float PiTransProb)

void	Gli_ManSetPiFromSaved (Gli_Man_t *p, int iBit)

void	Gli_ManSwitching (Gli_Man_t *p)

void	Gli_ManGlitching (Gli_Man_t *p)

void	Gli_ManVerify (Gli_Man_t *p)

unsigned	Gli_ManSimulateSeqNode (Gli_Man_t p, Gli_Obj_t pNode)

void	Gli_ManSimulateSeqPref (Gli_Man_t *p, int nPref)

void	Gli_ManSetDataSaved (Gli_Man_t *p, int iBit)

void	Gli_ManSetPiRandomSeq (Gli_Man_t *p, float PiTransProb)

void	Gli_ManSwitchesAndGlitches (Gli_Man_t *p, int nPatterns, float PiTransProb, int fVerbose)

Macro Definition Documentation

◆ Gli_ManForEachCi

#define Gli_ManForEachCi	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(p->vCis)) && (pObj = Gli_ManObj(p,Vec_IntEntry(p->vCis,i))); i++ )

p

Cube * p

Definition exorList.c:222

Definition at line 108 of file giaGlitch.c.

108#define Gli_ManForEachCi( p, pObj, i ) \

109 for ( i = 0; (i < Vec_IntSize(p->vCis)) && (pObj = Gli_ManObj(p,Vec_IntEntry(p->vCis,i))); i++ )

◆ Gli_ManForEachCo

#define Gli_ManForEachCo	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(p->vCos)) && (pObj = Gli_ManObj(p,Vec_IntEntry(p->vCos,i))); i++ )

Definition at line 110 of file giaGlitch.c.

110#define Gli_ManForEachCo( p, pObj, i ) \

111 for ( i = 0; (i < Vec_IntSize(p->vCos)) && (pObj = Gli_ManObj(p,Vec_IntEntry(p->vCos,i))); i++ )

◆ Gli_ManForEachEntry

#define Gli_ManForEachEntry	(	vVec,
		p,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(vVec)) && (pObj = Gli_ManObj(p,Vec_IntEntry(vVec,i))); i++ )

Definition at line 106 of file giaGlitch.c.

106#define Gli_ManForEachEntry( vVec, p, pObj, i ) \

107 for ( i = 0; (i < Vec_IntSize(vVec)) && (pObj = Gli_ManObj(p,Vec_IntEntry(vVec,i))); i++ )

◆ Gli_ManForEachNode

#define Gli_ManForEachNode	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < p->nObjData) && (pObj = Gli_ManObj(p,i)); i += Gli_ObjSize(pObj) ) if ( Gli_ObjIsTerm(pObj) ) {} else

Definition at line 103 of file giaGlitch.c.

103#define Gli_ManForEachNode( p, pObj, i ) \

104 for ( i = 0; (i < p->nObjData) && (pObj = Gli_ManObj(p,i)); i += Gli_ObjSize(pObj) ) if ( Gli_ObjIsTerm(pObj) ) {} else

◆ Gli_ManForEachObj

#define Gli_ManForEachObj	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < p->nObjData) && (pObj = Gli_ManObj(p,i)); i += Gli_ObjSize(pObj) )

Definition at line 101 of file giaGlitch.c.

101#define Gli_ManForEachObj( p, pObj, i ) \

102 for ( i = 0; (i < p->nObjData) && (pObj = Gli_ManObj(p,i)); i += Gli_ObjSize(pObj) )

◆ Gli_ManForEachPi

#define Gli_ManForEachPi	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gli_ManPiNum(p)) && ((pObj) = Gli_ManCi(p, i)); i++ )

Definition at line 113 of file giaGlitch.c.

113#define Gli_ManForEachPi( p, pObj, i ) \

114 for ( i = 0; (i < Gli_ManPiNum(p)) && ((pObj) = Gli_ManCi(p, i)); i++ )

◆ Gli_ManForEachPo

#define Gli_ManForEachPo	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gli_ManPoNum(p)) && ((pObj) = Gli_ManCo(p, i)); i++ )

Definition at line 115 of file giaGlitch.c.

115#define Gli_ManForEachPo( p, pObj, i ) \

116 for ( i = 0; (i < Gli_ManPoNum(p)) && ((pObj) = Gli_ManCo(p, i)); i++ )

◆ Gli_ManForEachRi

#define Gli_ManForEachRi	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gli_ManRegNum(p)) && ((pObj) = Gli_ManCo(p, Gli_ManPoNum(p)+i)); i++ )

Definition at line 119 of file giaGlitch.c.

119#define Gli_ManForEachRi( p, pObj, i ) \

120 for ( i = 0; (i < Gli_ManRegNum(p)) && ((pObj) = Gli_ManCo(p, Gli_ManPoNum(p)+i)); i++ )

◆ Gli_ManForEachRiRo

#define Gli_ManForEachRiRo	(	p,
		pObjRi,
		pObjRo,
		i )

Value:

for ( i = 0; (i < Gli_ManRegNum(p)) && ((pObjRi) = Gli_ManCo(p, Gli_ManPoNum(p)+i)) && ((pObjRo) = Gli_ManCi(p, Gli_ManPiNum(p)+i)); i++ )

Definition at line 121 of file giaGlitch.c.

121#define Gli_ManForEachRiRo( p, pObjRi, pObjRo, i ) \

122 for ( i = 0; (i < Gli_ManRegNum(p)) && ((pObjRi) = Gli_ManCo(p, Gli_ManPoNum(p)+i)) && ((pObjRo) = Gli_ManCi(p, Gli_ManPiNum(p)+i)); i++ )

◆ Gli_ManForEachRo

#define Gli_ManForEachRo	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gli_ManRegNum(p)) && ((pObj) = Gli_ManCi(p, Gli_ManPiNum(p)+i)); i++ )

Definition at line 117 of file giaGlitch.c.

117#define Gli_ManForEachRo( p, pObj, i ) \

118 for ( i = 0; (i < Gli_ManRegNum(p)) && ((pObj) = Gli_ManCi(p, Gli_ManPiNum(p)+i)); i++ )

◆ Gli_ObjForEachFanin

#define Gli_ObjForEachFanin	(	pObj,
		pNext,
		i )

Value:

for ( i = 0; (i < (int)pObj->nFanins) && (pNext = Gli_ObjFanin(pObj,i)); i++ )

Definition at line 124 of file giaGlitch.c.

124#define Gli_ObjForEachFanin( pObj, pNext, i ) \

125 for ( i = 0; (i < (int)pObj->nFanins) && (pNext = Gli_ObjFanin(pObj,i)); i++ )

◆ Gli_ObjForEachFanout

#define Gli_ObjForEachFanout	(	pObj,
		pNext,
		i )

Value:

for ( i = 0; (i < (int)pObj->nFanouts) && (pNext = Gli_ObjFanout(pObj,i)); i++ )

Definition at line 126 of file giaGlitch.c.

126#define Gli_ObjForEachFanout( pObj, pNext, i ) \

127 for ( i = 0; (i < (int)pObj->nFanouts) && (pNext = Gli_ObjFanout(pObj,i)); i++ )

Typedef Documentation

◆ Gli_Man_t

typedef struct Gli_Man_t_ Gli_Man_t

Definition at line 55 of file giaGlitch.c.

◆ Gli_Obj_t

typedef typedefABC_NAMESPACE_IMPL_START struct Gli_Obj_t_ Gli_Obj_t

DECLARATIONS ///.

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

FileName [giaGlitch.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Glitch simulation.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 30 of file giaGlitch.c.

Function Documentation

◆ Gli_ManAlloc()

Gli_Man_t * Gli_ManAlloc	(	int	nObjs,
		int	nRegs,
		int	nFanioPairs )

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 144 of file giaGlitch.c.

{
    Gli_Man_t * p;
    p = (Gli_Man_t *)ABC_CALLOC( int, (sizeof(Gli_Man_t) / 4) + (sizeof(Gli_Obj_t) / 4) * nObjs + 2 * nFanioPairs );
    p->nRegs = nRegs;
    p->vCis = Vec_IntAlloc( 1000 );
    p->vCos = Vec_IntAlloc( 1000 );
    p->vCisChanged = Vec_IntAlloc( 1000 );
    p->vAffected = Vec_IntAlloc( 1000 );
    p->vFrontier = Vec_IntAlloc( 1000 );
    p->nObjData = (sizeof(Gli_Obj_t) / 4) * nObjs + 2 * nFanioPairs;
    p->pObjData = (int *)(p + 1);
    return p;
}

Here is the caller graph for this function:

◆ Gli_ManCreateCi()

int Gli_ManCreateCi	(	Gli_Man_t *	p,
		int	nFanouts )

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

Synopsis [Creates CI.]

Description []

SideEffects []

SeeAlso []

Definition at line 288 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    pObj = Gli_ObjAlloc( p, 0, nFanouts );
    pObj->fTerm = 1;
    Vec_IntPush( p->vCis, pObj->Handle );
    return pObj->Handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManCreateCo()

int Gli_ManCreateCo	(	Gli_Man_t *	p,
		int	iFanin )

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

Synopsis [Creates CO.]

Description []

SideEffects []

SeeAlso []

Definition at line 308 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pFanin;
    pObj = Gli_ObjAlloc( p, 1, 0 );
    pObj->fTerm = 1;
    pFanin = Gli_ManObj( p, iFanin );
    Gli_ObjAddFanin( pObj, pFanin );
    pObj->fPhase = pObj->fPhase2 = pFanin->fPhase;
    Vec_IntPush( p->vCos, pObj->Handle );
    return pObj->Handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManCreateNode()

int Gli_ManCreateNode	(	Gli_Man_t *	p,
		Vec_Int_t *	vFanins,
		int	nFanouts,
		word *	pGateTruth )

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

Synopsis [Creates node.]

Description []

SideEffects []

SeeAlso []

Definition at line 369 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pFanin;
    int i;
    assert( Vec_IntSize(vFanins) <= 16 );
    pObj = Gli_ObjAlloc( p, Vec_IntSize(vFanins), nFanouts );
    Gli_ManForEachEntry( vFanins, p, pFanin, i )
        Gli_ObjAddFanin( pObj, pFanin );
    pObj->pTruth = pGateTruth;
    pObj->fPhase = pObj->fPhase2 = Gli_NodeComputeValue( pObj );
    return pObj->Handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManFinalize()

void Gli_ManFinalize ( Gli_Man_t * p )

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

Synopsis [Checks logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 221 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    int i;
    assert( p->iObjData == p->nObjData );
    Gli_ManForEachObj( p, pObj, i )
    {
        assert( pObj->iFanin == (int)pObj->nFanins );
        assert( pObj->iFanout == (int)pObj->nFanouts );
        pObj->iFanin = 0;
        pObj->iFanout = 0;
    }
}

Here is the caller graph for this function:

◆ Gli_ManGlitching()

void Gli_ManGlitching ( Gli_Man_t * p )

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

Synopsis [Computes glitching activity of each node.]

Description []

SideEffects []

SeeAlso []

Definition at line 506 of file giaGlitch.c.

{
    Gli_Obj_t * pThis, * pFanout;//, * pOther = Gli_ManObj(p, 41);
    int i, k, Handle;
//    Gli_ManForEachObj( p, pThis, i )
//        assert( pThis->fMark == 0 );
    // start the array of affected nodes
    Vec_IntClear( p->vAffected );
    Vec_IntForEachEntry( p->vCisChanged, Handle, i )
        Vec_IntPush( p->vAffected, Handle );
    // iteration propagation
    while ( Vec_IntSize(p->vAffected) > 0 )
    {
        // compute the frontier
        Vec_IntClear( p->vFrontier );
        Gli_ManForEachEntry( p->vAffected, p, pThis, i )
        {
            Gli_ObjForEachFanout( pThis, pFanout, k )
            {
                if ( Gli_ObjIsCo(pFanout) )
                    continue;
                if ( pFanout->fMark )
                    continue;
                pFanout->fMark = 1;
                Vec_IntPush( p->vFrontier, pFanout->Handle );
            }
        }
        // compute the next set of affected nodes
        Vec_IntClear( p->vAffected );
        Gli_ManForEachEntry( p->vFrontier, p, pThis, i )
        {
            pThis->fMark = 0;
            if ( ((int)pThis->fPhase2) == Gli_NodeComputeValue2(pThis) )
                continue;
            pThis->fPhase2 ^= 1;
            pThis->nGlitches++;
            Vec_IntPush( p->vAffected, pThis->Handle );
        }
    }
}

Here is the caller graph for this function:

◆ Gli_ManPrintObjects()

void Gli_ManPrintObjects ( Gli_Man_t * p )

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

Synopsis [Checks logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pNext;
    int i, k;
    Gli_ManForEachObj( p, pObj, i )
    {
        printf( "Node %d \n", pObj->Handle );
        printf( "Fanins: " );
        Gli_ObjForEachFanin( pObj, pNext, k )
            printf( "%d ", pNext->Handle );
        printf( "\n" );
        printf( "Fanouts: " );
        Gli_ObjForEachFanout( pObj, pNext, k )
            printf( "%d ", pNext->Handle );
        printf( "\n" );
    }
}

◆ Gli_ManSetDataSaved()

void Gli_ManSetDataSaved	(	Gli_Man_t *	p,
		int	iBit )

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

Synopsis [Initialized object values to be one pattern in the saved data.]

Description []

SideEffects []

SeeAlso []

Definition at line 675 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    int i;
    Gli_ManForEachCi( p, pObj, i )
        pObj->fPhase = pObj->fPhase2 = ((p->pSimInfoPrev[i] >> iBit) & 1);
    Gli_ManForEachNode( p, pObj, i )
        pObj->fPhase = pObj->fPhase2 = Gli_NodeComputeValue( pObj );
}

Here is the caller graph for this function:

◆ Gli_ManSetPiFromSaved()

void Gli_ManSetPiFromSaved	(	Gli_Man_t *	p,
		int	iBit )

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

Synopsis [Sets random info at the PIs and collects changed PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 455 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    int i;
    Vec_IntClear( p->vCisChanged );
    Gli_ManForEachCi( p, pObj, i )
        if ( (p->pSimInfoPrev[i] ^ pObj->uSimInfo) & (1 << iBit) )
        {
            Vec_IntPush( p->vCisChanged, pObj->Handle );
            pObj->fPhase  ^= 1;
            pObj->fPhase2 ^= 1;
            pObj->nSwitches++;
            pObj->nGlitches++;
        }
}

◆ Gli_ManSetPiRandom()

void Gli_ManSetPiRandom	(	Gli_Man_t *	p,
		float	PiTransProb )

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

Synopsis [Sets random info at the PIs and collects changed PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 426 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    float Multi = 1.0 / (1 << 16);
    int i;
    assert( 0.0 < PiTransProb && PiTransProb < 1.0 );
    Vec_IntClear( p->vCisChanged );
    Gli_ManForEachCi( p, pObj, i )
        if ( Multi * (Gia_ManRandom(0) & 0xffff) < PiTransProb )
        {
            Vec_IntPush( p->vCisChanged, pObj->Handle );
            pObj->fPhase  ^= 1;
            pObj->fPhase2 ^= 1;
            pObj->nSwitches++;
            pObj->nGlitches++;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManSetPiRandomSeq()

void Gli_ManSetPiRandomSeq	(	Gli_Man_t *	p,
		float	PiTransProb )

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

Synopsis [Sets random info at the PIs and collects changed PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 696 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pObjRi;
    float Multi = 1.0 / (1 << 16);
    int i;
    assert( 0.0 < PiTransProb && PiTransProb < 1.0 );
    // transfer data to the COs
    Gli_ManForEachCo( p, pObj, i )
        pObj->fPhase = pObj->fPhase2 = Gli_ObjFanin(pObj, 0)->fPhase;
    // set changed PIs
    Vec_IntClear( p->vCisChanged );
    Gli_ManForEachPi( p, pObj, i )
        if ( Multi * (Gia_ManRandom(0) & 0xffff) < PiTransProb )
        {
            Vec_IntPush( p->vCisChanged, pObj->Handle );
            pObj->fPhase  ^= 1;
            pObj->fPhase2 ^= 1;
            pObj->nSwitches++;
            pObj->nGlitches++;
        }
    // set changed ROs
    Gli_ManForEachRiRo( p, pObjRi, pObj, i )
        if ( pObjRi->fPhase != pObj->fPhase )
        {
            Vec_IntPush( p->vCisChanged, pObj->Handle );
            pObj->fPhase  ^= 1;
            pObj->fPhase2 ^= 1;
            pObj->nSwitches++;
            pObj->nGlitches++;
        }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManSimulateSeqNode()

unsigned Gli_ManSimulateSeqNode	(	Gli_Man_t *	p,
		Gli_Obj_t *	pNode )

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

Synopsis [Simulates one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 580 of file giaGlitch.c.

{
    unsigned pSimInfos[6], Result = 0;
    int nFanins = Gli_ObjFaninNum(pNode);
    int i, k, Phase;
    Gli_Obj_t * pFanin;
    assert( nFanins <= 16 );
    Gli_ObjForEachFanin( pNode, pFanin, i )
        pSimInfos[i] = pFanin->uSimInfo;
    for ( i = 0; i < 32; i++ )
    {
        Phase = 0;
        for ( k = 0; k < nFanins; k++ )
            if ( (pSimInfos[k] >> i) & 1 )
                Phase |= (1 << k);
        if ( Abc_InfoHasBit( (unsigned *)pNode->pTruth, Phase ) )
            Result |= (1 << i);
    }
    return Result;
}

Here is the caller graph for this function:

◆ Gli_ManSimulateSeqPref()

void Gli_ManSimulateSeqPref	(	Gli_Man_t *	p,
		int	nPref )

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

Synopsis [Simulates sequential network randomly for the given number of frames.]

Description []

SideEffects []

SeeAlso []

Definition at line 635 of file giaGlitch.c.

{
    Gli_Obj_t * pObj, * pObjRi, * pObjRo;
    int i, f;
    // initialize simulation data
    Gli_ManForEachPi( p, pObj, i )
        pObj->uSimInfo = Gli_ManUpdateRandomInput( pObj->uSimInfo, 0.5 );
    Gli_ManForEachRo( p, pObj, i )
        pObj->uSimInfo = 0;
    for ( f = 0; f < nPref; f++ )
    {
        // simulate one frame
        Gli_ManForEachNode( p, pObj, i )
            pObj->uSimInfo = Gli_ManSimulateSeqNode( p, pObj );
        Gli_ManForEachRi( p, pObj, i )
            pObj->uSimInfo = Gli_ObjFanin(pObj, 0)->uSimInfo;
        // initialize the next frame
        Gli_ManForEachPi( p, pObj, i )
            pObj->uSimInfo = Gli_ManUpdateRandomInput( pObj->uSimInfo, 0.5 );
        Gli_ManForEachRiRo( p, pObjRi, pObjRo, i )
            pObjRo->uSimInfo = pObjRi->uSimInfo;
    }
    // save simulation data after nPref timeframes
    if ( p->pSimInfoPrev == NULL )
        p->pSimInfoPrev = ABC_ALLOC( unsigned, Gli_ManCiNum(p) );
    Gli_ManForEachCi( p, pObj, i )
        p->pSimInfoPrev[i] = pObj->uSimInfo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManStop()

void Gli_ManStop ( Gli_Man_t * p )

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

Synopsis [Deletes logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file giaGlitch.c.

{
    Vec_IntFree( p->vCis );
    Vec_IntFree( p->vCos );
    Vec_IntFree( p->vCisChanged );
    Vec_IntFree( p->vAffected );
    Vec_IntFree( p->vFrontier );
    ABC_FREE( p->pSimInfoPrev );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Gli_ManSwitchesAndGlitches()

void Gli_ManSwitchesAndGlitches	(	Gli_Man_t *	p,
		int	nPatterns,
		float	PiTransProb,
		int	fVerbose )

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

Synopsis [Computes glitching activity of each node.]

Description []

SideEffects []

SeeAlso []

Definition at line 740 of file giaGlitch.c.

{
    int i, k;
    abctime clk = Abc_Clock();
    Gia_ManRandom( 1 );
    Gli_ManFinalize( p );
    if ( p->nRegs == 0 )
    {
        for ( i = 0; i < nPatterns; i++ )
        {
            Gli_ManSetPiRandom( p, PiTransProb );
            Gli_ManSwitching( p );
            Gli_ManGlitching( p );
//            Gli_ManVerify( p );
        }
    }
    else 
    {
        int nIters = Abc_BitWordNum(nPatterns);
        Gli_ManSimulateSeqPref( p, 16 );
        for ( i = 0; i < 32; i++ )
        {
            Gli_ManSetDataSaved( p, i );
            for ( k = 0; k < nIters; k++ )
            {
                Gli_ManSetPiRandomSeq( p, PiTransProb );
                Gli_ManSwitching( p );
                Gli_ManGlitching( p );
//                Gli_ManVerify( p );
            }
        }
    }
    if ( fVerbose )
    {
        printf( "Simulated %d patterns.  Input transition probability %.2f.  ", nPatterns, PiTransProb );
        ABC_PRMn( "Memory", 4*p->nObjData );
        ABC_PRT( "Time", Abc_Clock() - clk );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gli_ManSwitching()

void Gli_ManSwitching ( Gli_Man_t * p )

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

Synopsis [Computes switching activity of each node.]

Description []

SideEffects []

SeeAlso []

Definition at line 482 of file giaGlitch.c.

{
    Gli_Obj_t * pThis;
    int i;
    Gli_ManForEachNode( p, pThis, i )
    {
        if ( ((int)pThis->fPhase) == Gli_NodeComputeValue(pThis) )
            continue;
        pThis->fPhase ^= 1;
        pThis->nSwitches++;
    }
}

Here is the caller graph for this function:

◆ Gli_ManVerify()

void Gli_ManVerify ( Gli_Man_t * p )

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

Synopsis [Checks that the resulting values are the same.]

Description []

SideEffects []

SeeAlso []

Definition at line 558 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    int i;
    Gli_ManForEachObj( p, pObj, i )
    {
        assert( pObj->fPhase == pObj->fPhase2 );
        assert( pObj->nGlitches >= pObj->nSwitches );
    }
}

◆ Gli_ObjAddFanin()

void Gli_ObjAddFanin	(	Gli_Obj_t *	pObj,
		Gli_Obj_t *	pFanin )

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

Synopsis [Creates fanin/fanout pair.]

Description []

SideEffects []

SeeAlso []

Definition at line 246 of file giaGlitch.c.

{ 
    assert( pObj->iFanin < (int)pObj->nFanins );
    assert( pFanin->iFanout < (int)pFanin->nFanouts );
    pFanin->Fanios[pFanin->nFanins + pFanin->iFanout++] = 
    pObj->Fanios[pObj->iFanin++] = pObj->Handle - pFanin->Handle;
}

Here is the caller graph for this function:

◆ Gli_ObjAlloc()

Gli_Obj_t * Gli_ObjAlloc	(	Gli_Man_t *	p,
		int	nFanins,
		int	nFanouts )

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

Synopsis [Allocates object.]

Description []

SideEffects []

SeeAlso []

Definition at line 265 of file giaGlitch.c.

{
    Gli_Obj_t * pObj;
    pObj = Gli_ManObj( p, p->iObjData );
    pObj->Handle   = p->iObjData;
    pObj->nFanins  = nFanins;
    pObj->nFanouts = nFanouts;
    p->iObjData += Gli_ObjSize( pObj );
    p->nObjs++;
    return pObj;
}

Here is the caller graph for this function:

◆ Gli_ObjNumGlitches()

int Gli_ObjNumGlitches	(	Gli_Man_t *	p,
		int	iNode )

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

Synopsis [Returns the number of glitches of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 409 of file giaGlitch.c.

{
    return Gli_ManObj( p, iNode )->nGlitches;
}

Here is the caller graph for this function:

◆ Gli_ObjNumSwitches()

int Gli_ObjNumSwitches	(	Gli_Man_t *	p,
		int	iNode )

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

Synopsis [Returns the number of switches of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 393 of file giaGlitch.c.

{
    return Gli_ManObj( p, iNode )->nSwitches;
}

Here is the caller graph for this function:

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ Gli_ManForEachCi

◆ Gli_ManForEachCo

◆ Gli_ManForEachEntry

◆ Gli_ManForEachNode

◆ Gli_ManForEachObj

◆ Gli_ManForEachPi

◆ Gli_ManForEachPo

◆ Gli_ManForEachRi

◆ Gli_ManForEachRiRo

◆ Gli_ManForEachRo

◆ Gli_ObjForEachFanin

◆ Gli_ObjForEachFanout

Typedef Documentation

◆ Gli_Man_t

◆ Gli_Obj_t

Function Documentation

◆ Gli_ManAlloc()

◆ Gli_ManCreateCi()

◆ Gli_ManCreateCo()

◆ Gli_ManCreateNode()

◆ Gli_ManFinalize()

◆ Gli_ManGlitching()

◆ Gli_ManPrintObjects()

◆ Gli_ManSetDataSaved()

◆ Gli_ManSetPiFromSaved()

◆ Gli_ManSetPiRandom()

◆ Gli_ManSetPiRandomSeq()

◆ Gli_ManSimulateSeqNode()

◆ Gli_ManSimulateSeqPref()

◆ Gli_ManStop()

◆ Gli_ManSwitchesAndGlitches()

◆ Gli_ManSwitching()

◆ Gli_ManVerify()

◆ Gli_ObjAddFanin()

◆ Gli_ObjAlloc()

◆ Gli_ObjNumGlitches()

◆ Gli_ObjNumSwitches()