saigSwitch.c File Reference

#include "saig.h"
#include "base/main/main.h"

Include dependency graph for saigSwitch.c:

Go to the source code of this file.

Classes
struct	Saig_SimObj_t_
struct	Aig_CMan_t_

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Saig_SimObj_t_	Saig_SimObj_t
	DECLARATIONS ///.
typedef struct Aig_CMan_t_	Aig_CMan_t

Functions
Saig_SimObj_t *	Saig_ManCreateMan (Aig_Man_t *p)
	FUNCTION DEFINITIONS ///.
void	Saig_ManSimulateFrames (Saig_SimObj_t *pAig, int nFrames, int nPref)
float	Saig_ManComputeSwitching (int nOnes, int nSimWords)
float	Saig_ManComputeProbOne (int nOnes, int nSimWords)
float	Saig_ManComputeProbOnePlus (int nOnes, int nSimWords, int fCompl)
Vec_Int_t *	Saig_ManComputeSwitchProb4s (Aig_Man_t *p, int nFrames, int nPref, int fProbOne)
Aig_CMan_t *	Aig_CManStart (int nIns, int nNodes, int nOuts)
void	Aig_CManStop (Aig_CMan_t *p)
void	Aig_CManRestart (Aig_CMan_t *p)
void	Aig_CManStoreNum (Aig_CMan_t *p, unsigned x)
int	Aig_CManRestoreNum (Aig_CMan_t *p)
void	Aig_CManAddNode (Aig_CMan_t *p, int iFan0, int iFan1)
void	Aig_CManAddPo (Aig_CMan_t *p, int iFan0)
void	Aig_CManGetNode (Aig_CMan_t *p, int *piFan0, int *piFan1)
int	Aig_CManGetPo (Aig_CMan_t *p)
Aig_CMan_t *	Aig_CManCreate (Aig_Man_t *p)

Typedef Documentation

Aig_CMan_t

typedef struct Aig_CMan_t_ Aig_CMan_t

Definition at line 331 of file saigSwitch.c.

Saig_SimObj_t

typedef typedefABC_NAMESPACE_IMPL_START struct Saig_SimObj_t_ Saig_SimObj_t

DECLARATIONS ///.

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

FileName [saigSwitch.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Sequential AIG package.]

Synopsis [Returns switching propabilities.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 32 of file saigSwitch.c.

Function Documentation

Aig_CManAddNode()

void Aig_CManAddNode	(	Aig_CMan_t *	p,
		int	iFan0,
		int	iFan1 )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 466 of file saigSwitch.c.

{
    assert( iFan0 < iFan1 );
    assert( iFan1 < (p->iNode << 1) );
    Aig_CManStoreNum( p, (p->iNode++ << 1) - iFan1 );
    Aig_CManStoreNum( p, iFan1 - iFan0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Aig_CManAddPo()

void Aig_CManAddPo	(	Aig_CMan_t *	p,
		int	iFan0 )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 485 of file saigSwitch.c.

{
    if ( p->iPrev == -1 )
        Aig_CManStoreNum( p, p->iNode - iFan0 );
    else if ( p->iPrev <= iFan0 )
        Aig_CManStoreNum( p, (iFan0 - p->iPrev) << 1 );
    else 
        Aig_CManStoreNum( p,((p->iPrev - iFan0) << 1) | 1 );
    p->iPrev = iFan0;
    p->iNode++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Aig_CManCreate()

Aig_CMan_t * Aig_CManCreate

(

Aig_Man_t *

p

)

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

Synopsis [Compute switching probabilities of all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 547 of file saigSwitch.c.

{
    Aig_CMan_t * pCMan;
    Aig_Obj_t * pObj;
    int i;
    pCMan = Aig_CManStart( Aig_ManCiNum(p), Aig_ManNodeNum(p), Aig_ManCoNum(p) );
    Aig_ManForEachNode( p, pObj, i )
        Aig_CManAddNode( pCMan, 
            (Aig_ObjFaninId0(pObj) << 1) | Aig_ObjFaninC0(pObj), 
            (Aig_ObjFaninId1(pObj) << 1) | Aig_ObjFaninC1(pObj) );
    Aig_ManForEachCo( p, pObj, i )
        Aig_CManAddPo( pCMan, 
            (Aig_ObjFaninId0(pObj) << 1) | Aig_ObjFaninC0(pObj) ); 
    printf( "\nBytes alloc = %5d.  Bytes used = %7d.  Ave per node = %4.2f. \n", 
        pCMan->nBytes, (int)(pCMan->pCur - pCMan->Data), 
        1.0 * (pCMan->pCur - pCMan->Data) / (pCMan->nNodes + pCMan->nOuts ) );
//    Aig_CManStop( pCMan );
    return pCMan;
}

Here is the call graph for this function:

Aig_CManGetNode()

void Aig_CManGetNode	(	Aig_CMan_t *	p,
		int *	piFan0,
		int *	piFan1 )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 508 of file saigSwitch.c.

{
    *piFan1 = (p->iNode++ << 1) - Aig_CManRestoreNum( p );
    *piFan0 = *piFan1 - Aig_CManRestoreNum( p );
}

Here is the call graph for this function:

Aig_CManGetPo()

int Aig_CManGetPo

(

Aig_CMan_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 525 of file saigSwitch.c.

{
    int Num = Aig_CManRestoreNum( p );
    if ( p->iPrev == -1 )
        p->iPrev = p->iNode;
    p->iNode++;
    if ( Num & 1 )
        return p->iPrev = p->iPrev + (Num >> 1);
    return p->iPrev = p->iPrev - (Num >> 1);
}

Here is the call graph for this function:

Aig_CManRestart()

void Aig_CManRestart

(

Aig_CMan_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 405 of file saigSwitch.c.

{
    assert( p->iNode == 1 + p->nIns + p->nNodes + p->nOuts );
    p->iNode = 1 + p->nIns;
    p->iPrev = -1;
    p->pCur = p->Data;
}

Aig_CManRestoreNum()

int Aig_CManRestoreNum

(

Aig_CMan_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 447 of file saigSwitch.c.

{
    int ch, i, x = 0;
    for ( i = 0; (ch = *p->pCur++) & 0x80; i++ )
        x |= (ch & 0x7f) << (7 * i);
    return x | (ch << (7 * i));
}

Here is the caller graph for this function:

Aig_CManStart()

Aig_CMan_t * Aig_CManStart	(	int	nIns,
		int	nNodes,
		int	nOuts )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 361 of file saigSwitch.c.

{
    Aig_CMan_t * p;
    p = (Aig_CMan_t *)ABC_ALLOC( char, sizeof(Aig_CMan_t) + 2*(2*nNodes + nOuts) );
    memset( p, 0, sizeof(Aig_CMan_t) );
    // set parameters
    p->nIns = nIns;
    p->nOuts = nOuts;
    p->nNodes = nNodes;
    p->nBytes = 2*(2*nNodes + nOuts);
    // prepare the manager
    p->iNode = 1 + p->nIns;
    p->iPrev = -1;
    p->pCur = p->Data;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Aig_CManStop()

void Aig_CManStop

(

Aig_CMan_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 389 of file saigSwitch.c.

{
    ABC_FREE( p );
}

Aig_CManStoreNum()

void Aig_CManStoreNum	(	Aig_CMan_t *	p,
		unsigned	x )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 425 of file saigSwitch.c.

{
    while ( x & ~0x7f )
    {
        *p->pCur++ = (x & 0x7f) | 0x80;
        x >>= 7;
    }
    *p->pCur++ = x;
    assert( p->pCur - p->Data < p->nBytes - 10 );
}

Here is the caller graph for this function:

Saig_ManComputeProbOne()

float Saig_ManComputeProbOne	(	int	nOnes,
		int	nSimWords )

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

Synopsis [Computes switching activity of one node.]

Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ]

SideEffects []

SeeAlso []

Definition at line 229 of file saigSwitch.c.

{
    int nTotal = 32 * nSimWords;
    return (float)nOnes / nTotal;
}

Here is the caller graph for this function:

Saig_ManComputeProbOnePlus()

float Saig_ManComputeProbOnePlus	(	int	nOnes,
		int	nSimWords,
		int	fCompl )

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

Synopsis [Computes switching activity of one node.]

Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ]

SideEffects []

SeeAlso []

Definition at line 246 of file saigSwitch.c.

{
    int nTotal = 32 * nSimWords;
    if ( fCompl )
        return (float)(nTotal-nOnes) / nTotal;
    else
        return (float)nOnes / nTotal;
}

Saig_ManComputeSwitching()

float Saig_ManComputeSwitching	(	int	nOnes,
		int	nSimWords )

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

Synopsis [Computes switching activity of one node.]

Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ]

SideEffects []

SeeAlso []

Definition at line 212 of file saigSwitch.c.

{
    int nTotal = 32 * nSimWords;
    return (float)2.0 * nOnes / nTotal * (nTotal - nOnes) / nTotal;
}

Here is the caller graph for this function:

Saig_ManComputeSwitchProb4s()

Vec_Int_t * Saig_ManComputeSwitchProb4s	(	Aig_Man_t *	p,
		int	nFrames,
		int	nPref,
		int	fProbOne )

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

Synopsis [Compute switching probabilities of all nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 266 of file saigSwitch.c.

{
    Saig_SimObj_t * pAig, * pEntry;
    Vec_Int_t * vSwitching;
    float * pSwitching;
    int nFramesReal;
    abctime clk;//, clkTotal = Abc_Clock();
    vSwitching = Vec_IntStart( Aig_ManObjNumMax(p) );
    pSwitching = (float *)vSwitching->pArray;
clk = Abc_Clock();
    pAig = Saig_ManCreateMan( p );
//ABC_PRT( "\nCreation  ", Abc_Clock() - clk );
 
    Aig_ManRandom( 1 );
    // get the number of  frames to simulate
    // if the parameter "seqsimframes" is defined, use it
    // otherwise, use the given number of frames "nFrames"
    nFramesReal = nFrames;
    if ( Abc_FrameReadFlag("seqsimframes") )
        nFramesReal = atoi( Abc_FrameReadFlag("seqsimframes") );
    if ( nFramesReal <= nPref )
    {
        printf( "The total number of frames (%d) should exceed prefix (%d).\n", nFramesReal, nPref );\
        printf( "Setting the total number of frames to be %d.\n", nFrames );
        nFramesReal = nFrames;
    }
//printf( "Simulating %d frames.\n", nFramesReal );
clk = Abc_Clock();
    Saig_ManSimulateFrames( pAig, nFramesReal, nPref );
//ABC_PRT( "Simulation", Abc_Clock() - clk );
clk = Abc_Clock();
    for ( pEntry = pAig; pEntry->Type != AIG_OBJ_VOID; pEntry++ )
    {
/*
        if ( pEntry->Type == AIG_OBJ_AND )
        {
        Saig_SimObj_t * pObj0 = pAig + Saig_SimObjFanin0( pEntry );
        Saig_SimObj_t * pObj1 = pAig + Saig_SimObjFanin1( pEntry );
        printf( "%5.2f = %5.2f * %5.2f  (%7.4f)\n", 
            Saig_ManComputeProbOnePlus( pEntry->Number, nFrames - nPref, 0 ),
            Saig_ManComputeProbOnePlus( pObj0->Number, nFrames - nPref, Saig_SimObjFaninC0(pEntry) ),
            Saig_ManComputeProbOnePlus( pObj1->Number, nFrames - nPref, Saig_SimObjFaninC1(pEntry) ),
            Saig_ManComputeProbOnePlus( pEntry->Number, nFrames - nPref, 0 ) -
            Saig_ManComputeProbOnePlus( pObj0->Number, nFrames - nPref, Saig_SimObjFaninC0(pEntry) ) *
            Saig_ManComputeProbOnePlus( pObj1->Number, nFrames - nPref, Saig_SimObjFaninC1(pEntry) )
            );
        }
*/
        if ( fProbOne )
            pSwitching[pEntry-pAig] = Saig_ManComputeProbOne( pEntry->Number, nFramesReal - nPref );
        else
            pSwitching[pEntry-pAig] = Saig_ManComputeSwitching( pEntry->Number, nFramesReal - nPref );
//printf( "%3d : %7.2f\n", pEntry-pAig, pSwitching[pEntry-pAig] );
    }
    ABC_FREE( pAig );
//ABC_PRT( "Switch    ", Abc_Clock() - clk );
//ABC_PRT( "TOTAL     ", Abc_Clock() - clkTotal );
 
//    Aig_CManCreate( p );
    return vSwitching;
}

Here is the call graph for this function:

Saig_ManCreateMan()

Saig_SimObj_t * Saig_ManCreateMan

(

Aig_Man_t *

p

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates fast simulation manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 66 of file saigSwitch.c.

{
    Saig_SimObj_t * pAig, * pEntry;
    Aig_Obj_t * pObj;
    int i;
    pAig = ABC_CALLOC( Saig_SimObj_t, Aig_ManObjNumMax(p)+1 );
//    printf( "Allocating %7.2f MB.\n", 1.0 * sizeof(Saig_SimObj_t) * (Aig_ManObjNumMax(p)+1)/(1<<20) );
    Aig_ManForEachObj( p, pObj, i )
    {
        pEntry = pAig + i;
        pEntry->Type = pObj->Type;
        if ( Aig_ObjIsCi(pObj) || i == 0 )
        {
            if ( Saig_ObjIsLo(p, pObj) )
            {
                pEntry->iFan0 = (Saig_ObjLoToLi(p, pObj)->Id << 1);
                pEntry->iFan1 = -1;
            }
            continue;
        }
        pEntry->iFan0 = (Aig_ObjFaninId0(pObj) << 1) | Aig_ObjFaninC0(pObj);
        if ( Aig_ObjIsCo(pObj) )
            continue;
        assert( Aig_ObjIsNode(pObj) );
        pEntry->iFan1 = (Aig_ObjFaninId1(pObj) << 1) | Aig_ObjFaninC1(pObj);
    }
    pEntry = pAig + Aig_ManObjNumMax(p);
    pEntry->Type = AIG_OBJ_VOID;
    return pAig;
}

Here is the caller graph for this function:

Saig_ManSimulateFrames()

void Saig_ManSimulateFrames	(	Saig_SimObj_t *	pAig,
		int	nFrames,
		int	nPref )

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

Synopsis [Simulates the timeframes.]

Description []

SideEffects []

SeeAlso []

Definition at line 172 of file saigSwitch.c.

{
    Saig_SimObj_t * pEntry;
    int f;
    for ( f = 0; f < nFrames; f++ )
    {
        for ( pEntry = pAig; pEntry->Type != AIG_OBJ_VOID; pEntry++ )
        {
            if ( pEntry->Type == AIG_OBJ_AND )
                Saig_ManSimulateNode( pAig, pEntry );
            else if ( pEntry->Type == AIG_OBJ_CO )
                Saig_ManSimulateOneInput( pAig, pEntry );
            else if ( pEntry->Type == AIG_OBJ_CI )
            {
                if ( pEntry->iFan0 == 0 ) // true PI
                    pEntry->pData[0] = Aig_ManRandom( 0 );
                else if ( f > 0 ) // register output
                    Saig_ManSimulateOneInput( pAig, pEntry );
            }
            else if ( pEntry->Type == AIG_OBJ_CONST1 )
                pEntry->pData[0] = ~0;
            else if ( pEntry->Type != AIG_OBJ_NONE )
                assert( 0 );
            if ( f >= nPref )
                pEntry->Number += Aig_WordCountOnes( pEntry->pData[0] );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: