/**CFile**************************************************************** FileName [giaSwitch.c] SystemName [ABC: Logic synthesis and verification system.] PackageName [Scalable AIG package.] Synopsis [Computing switching activity.] Author [Alan Mishchenko] Affiliation [UC Berkeley] Date [Ver. 1.0. Started - June 20, 2005.] Revision [$Id: giaSwitch.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] ***********************************************************************/ #include "giaAig.h" #include "base/main/main.h" ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// // switching estimation parameters typedef struct Gia_ParSwi_t_ Gia_ParSwi_t; struct Gia_ParSwi_t_ { // user-controlled parameters int nWords; // the number of machine words int nIters; // the number of timeframes int nPref; // the number of first timeframes to skip int nRandPiFactor; // PI trans prob (-1=3/8; 0=1/2; 1=1/4; 2=1/8, etc) int fProbOne; // collect probability of one int fProbTrans; // collect probatility of Swiing int fVerbose; // enables verbose output }; typedef struct Gia_ManSwi_t_ Gia_ManSwi_t; struct Gia_ManSwi_t_ { Gia_Man_t * pAig; Gia_ParSwi_t * pPars; int nWords; // simulation information unsigned * pDataSim; // simulation data unsigned * pDataSimCis; // simulation data for CIs unsigned * pDataSimCos; // simulation data for COs int * pData1; // switching data }; static inline unsigned * Gia_SwiData( Gia_ManSwi_t * p, int i ) { return p->pDataSim + i * p->nWords; } static inline unsigned * Gia_SwiDataCi( Gia_ManSwi_t * p, int i ) { return p->pDataSimCis + i * p->nWords; } static inline unsigned * Gia_SwiDataCo( Gia_ManSwi_t * p, int i ) { return p->pDataSimCos + i * p->nWords; } //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [This procedure sets default parameters.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Gia_ManSetDefaultParamsSwi( Gia_ParSwi_t * p ) { memset( p, 0, sizeof(Gia_ParSwi_t) ); p->nWords = 10; // the number of machine words of simulatation data p->nIters = 48; // the number of all timeframes to simulate p->nPref = 16; // the number of first timeframes to skip when computing switching p->nRandPiFactor = 0; // primary input transition probability (-1=3/8; 0=1/2; 1=1/4; 2=1/8, etc) p->fProbOne = 0; // compute probability of signal being one (if 0, compute probability of switching) p->fProbTrans = 1; // compute signal transition probability (if 0, compute transition probability using probability of being one) p->fVerbose = 0; // enables verbose output } /**Function************************************************************* Synopsis [Creates fast simulation manager.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Gia_ManSwi_t * Gia_ManSwiCreate( Gia_Man_t * pAig, Gia_ParSwi_t * pPars ) { Gia_ManSwi_t * p; p = ABC_ALLOC( Gia_ManSwi_t, 1 ); memset( p, 0, sizeof(Gia_ManSwi_t) ); p->pAig = Gia_ManFront( pAig ); p->pPars = pPars; p->nWords = pPars->nWords; p->pDataSim = ABC_ALLOC( unsigned, p->nWords * p->pAig->nFront ); p->pDataSimCis = ABC_ALLOC( unsigned, p->nWords * Gia_ManCiNum(p->pAig) ); p->pDataSimCos = ABC_ALLOC( unsigned, p->nWords * Gia_ManCoNum(p->pAig) ); p->pData1 = ABC_CALLOC( int, Gia_ManObjNum(pAig) ); return p; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Gia_ManSwiDelete( Gia_ManSwi_t * p ) { Gia_ManStop( p->pAig ); ABC_FREE( p->pData1 ); ABC_FREE( p->pDataSim ); ABC_FREE( p->pDataSimCis ); ABC_FREE( p->pDataSimCos ); ABC_FREE( p ); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoRandom( Gia_ManSwi_t * p, unsigned * pInfo, int nProbNum ) { unsigned Mask; int w, i; if ( nProbNum == -1 ) { // 3/8 = 1/4 + 1/8 Mask = (Gia_ManRandom( 0 ) & Gia_ManRandom( 0 )) | (Gia_ManRandom( 0 ) & Gia_ManRandom( 0 ) & Gia_ManRandom( 0 )); for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] ^= Mask; } else if ( nProbNum > 0 ) { Mask = Gia_ManRandom( 0 ); for ( i = 0; i < nProbNum; i++ ) Mask &= Gia_ManRandom( 0 ); for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] ^= Mask; } else if ( nProbNum == 0 ) { for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = Gia_ManRandom( 0 ); } else assert( 0 ); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoRandomShift( Gia_ManSwi_t * p, unsigned * pInfo, int nProbNum ) { unsigned Mask; int w, i; if ( nProbNum == -1 ) { // 3/8 = 1/4 + 1/8 Mask = (Gia_ManRandom( 0 ) & Gia_ManRandom( 0 )) | (Gia_ManRandom( 0 ) & Gia_ManRandom( 0 ) & Gia_ManRandom( 0 )); } else if ( nProbNum >= 0 ) { Mask = Gia_ManRandom( 0 ); for ( i = 0; i < nProbNum; i++ ) Mask &= Gia_ManRandom( 0 ); } else assert( 0 ); for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = (pInfo[w] << 16) | ((pInfo[w] ^ Mask) & 0xffff); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoZero( Gia_ManSwi_t * p, unsigned * pInfo ) { int w; for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = 0; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoOne( Gia_ManSwi_t * p, unsigned * pInfo ) { int w; for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = ~0; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoCopy( Gia_ManSwi_t * p, unsigned * pInfo, unsigned * pInfo0 ) { int w; for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = pInfo0[w]; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoCopyShift( Gia_ManSwi_t * p, unsigned * pInfo, unsigned * pInfo0 ) { int w; for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = (pInfo[w] << 16) | (pInfo0[w] & 0xffff); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimulateCi( Gia_ManSwi_t * p, Gia_Obj_t * pObj, int iCi ) { unsigned * pInfo = Gia_SwiData( p, Gia_ObjValue(pObj) ); unsigned * pInfo0 = Gia_SwiDataCi( p, iCi ); int w; for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = pInfo0[w]; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimulateCo( Gia_ManSwi_t * p, int iCo, Gia_Obj_t * pObj ) { unsigned * pInfo = Gia_SwiDataCo( p, iCo ); unsigned * pInfo0 = Gia_SwiData( p, Gia_ObjDiff0(pObj) ); int w; if ( Gia_ObjFaninC0(pObj) ) for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = ~pInfo0[w]; else for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = pInfo0[w]; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimulateNode( Gia_ManSwi_t * p, Gia_Obj_t * pObj ) { unsigned * pInfo = Gia_SwiData( p, Gia_ObjValue(pObj) ); unsigned * pInfo0 = Gia_SwiData( p, Gia_ObjDiff0(pObj) ); unsigned * pInfo1 = Gia_SwiData( p, Gia_ObjDiff1(pObj) ); int w; if ( Gia_ObjFaninC0(pObj) ) { if ( Gia_ObjFaninC1(pObj) ) for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = ~(pInfo0[w] | pInfo1[w]); else for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = ~pInfo0[w] & pInfo1[w]; } else { if ( Gia_ObjFaninC1(pObj) ) for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = pInfo0[w] & ~pInfo1[w]; else for ( w = p->nWords-1; w >= 0; w-- ) pInfo[w] = pInfo0[w] & pInfo1[w]; } } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoInit( Gia_ManSwi_t * p ) { int i = 0; for ( ; i < Gia_ManPiNum(p->pAig); i++ ) Gia_ManSwiSimInfoRandom( p, Gia_SwiDataCi(p, i), 0 ); for ( ; i < Gia_ManCiNum(p->pAig); i++ ) Gia_ManSwiSimInfoZero( p, Gia_SwiDataCi(p, i) ); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoTransfer( Gia_ManSwi_t * p, int nProbNum ) { int i = 0, nShift = Gia_ManPoNum(p->pAig)-Gia_ManPiNum(p->pAig); for ( ; i < Gia_ManPiNum(p->pAig); i++ ) Gia_ManSwiSimInfoRandom( p, Gia_SwiDataCi(p, i), nProbNum ); for ( ; i < Gia_ManCiNum(p->pAig); i++ ) Gia_ManSwiSimInfoCopy( p, Gia_SwiDataCi(p, i), Gia_SwiDataCo(p, nShift+i) ); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimInfoTransferShift( Gia_ManSwi_t * p, int nProbNum ) { int i = 0, nShift = Gia_ManPoNum(p->pAig)-Gia_ManPiNum(p->pAig); for ( ; i < Gia_ManPiNum(p->pAig); i++ ) Gia_ManSwiSimInfoRandomShift( p, Gia_SwiDataCi(p, i), nProbNum ); for ( ; i < Gia_ManCiNum(p->pAig); i++ ) Gia_ManSwiSimInfoCopyShift( p, Gia_SwiDataCi(p, i), Gia_SwiDataCo(p, nShift+i) ); } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline int Gia_ManSwiSimInfoCountOnes( Gia_ManSwi_t * p, int iPlace ) { unsigned * pInfo; int w, Counter = 0; pInfo = Gia_SwiData( p, iPlace ); for ( w = p->nWords-1; w >= 0; w-- ) Counter += Gia_WordCountOnes( pInfo[w] ); return Counter; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline int Gia_ManSwiSimInfoCountTrans( Gia_ManSwi_t * p, int iPlace ) { unsigned * pInfo; int w, Counter = 0; pInfo = Gia_SwiData( p, iPlace ); for ( w = p->nWords-1; w >= 0; w-- ) Counter += 2*Gia_WordCountOnes( (pInfo[w] ^ (pInfo[w] >> 16)) & 0xffff ); return Counter; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Gia_ManSwiSimulateRound( Gia_ManSwi_t * p, int fCount ) { Gia_Obj_t * pObj; int i;//, iCis = 0, iCos = 0; assert( p->pAig->nFront > 0 ); assert( Gia_ManConst0(p->pAig)->Value == 0 ); Gia_ManSwiSimInfoZero( p, Gia_SwiData(p, 0) ); Gia_ManForEachObj1( p->pAig, pObj, i ) { if ( Gia_ObjIsAndOrConst0(pObj) ) { assert( Gia_ObjValue(pObj) < p->pAig->nFront ); Gia_ManSwiSimulateNode( p, pObj ); } else if ( Gia_ObjIsCo(pObj) ) { assert( Gia_ObjValue(pObj) == GIA_NONE ); // Gia_ManSwiSimulateCo( p, iCos++, pObj ); Gia_ManSwiSimulateCo( p, Gia_ObjCioId(pObj), pObj ); } else // if ( Gia_ObjIsCi(pObj) ) { assert( Gia_ObjValue(pObj) < p->pAig->nFront ); // Gia_ManSwiSimulateCi( p, pObj, iCis++ ); Gia_ManSwiSimulateCi( p, pObj, Gia_ObjCioId(pObj) ); } if ( fCount && !Gia_ObjIsCo(pObj) ) { if ( p->pPars->fProbTrans ) p->pData1[i] += Gia_ManSwiSimInfoCountTrans( p, Gia_ObjValue(pObj) ); else p->pData1[i] += Gia_ManSwiSimInfoCountOnes( p, Gia_ObjValue(pObj) ); } } // assert( Gia_ManCiNum(p->pAig) == iCis ); // assert( Gia_ManCoNum(p->pAig) == iCos ); } /**Function************************************************************* Synopsis [Computes switching activity of one node.] Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ] SideEffects [] SeeAlso [] ***********************************************************************/ float Gia_ManSwiComputeSwitching( int nOnes, int nSimWords ) { int nTotal = 32 * nSimWords; return (float)2.0 * nOnes / nTotal * (nTotal - nOnes) / nTotal; } /**Function************************************************************* Synopsis [Computes switching activity of one node.] Description [Uses the formula: Switching = 2 * nOnes * nZeros / (nTotal ^ 2) ] SideEffects [] SeeAlso [] ***********************************************************************/ float Gia_ManSwiComputeProbOne( int nOnes, int nSimWords ) { int nTotal = 32 * nSimWords; return (float)nOnes / nTotal; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Vec_Int_t * Gia_ManSwiSimulate( Gia_Man_t * pAig, Gia_ParSwi_t * pPars ) { Gia_ManSwi_t * p; Gia_Obj_t * pObj; Vec_Int_t * vSwitching; float * pSwitching; int i; abctime clk, clkTotal = Abc_Clock(); if ( pPars->fProbOne && pPars->fProbTrans ) printf( "Conflict of options: Can either compute probability of 1, or probability of switching by observing transitions.\n" ); // create manager clk = Abc_Clock(); p = Gia_ManSwiCreate( pAig, pPars ); if ( pPars->fVerbose ) { printf( "Obj = %8d (%8d). F = %6d. ", pAig->nObjs, Gia_ManCiNum(pAig) + Gia_ManAndNum(pAig), p->pAig->nFront ); printf( "AIG = %7.2f MB. F-mem = %7.2f MB. Other = %7.2f MB. ", 12.0*Gia_ManObjNum(p->pAig)/(1<<20), 4.0*p->nWords*p->pAig->nFront/(1<<20), 4.0*p->nWords*(Gia_ManCiNum(p->pAig) + Gia_ManCoNum(p->pAig))/(1<<20) ); ABC_PRT( "Time", Abc_Clock() - clk ); } // perform simulation Gia_ManRandom( 1 ); Gia_ManSwiSimInfoInit( p ); for ( i = 0; i < pPars->nIters; i++ ) { Gia_ManSwiSimulateRound( p, i >= pPars->nPref ); if ( i == pPars->nIters - 1 ) break; if ( pPars->fProbTrans ) Gia_ManSwiSimInfoTransferShift( p, pPars->nRandPiFactor ); else Gia_ManSwiSimInfoTransfer( p, pPars->nRandPiFactor ); } if ( pPars->fVerbose ) { printf( "Simulated %d frames with %d words. ", pPars->nIters, pPars->nWords ); ABC_PRT( "Simulation time", Abc_Clock() - clkTotal ); } // derive the result vSwitching = Vec_IntStart( Gia_ManObjNum(pAig) ); pSwitching = (float *)vSwitching->pArray; if ( pPars->fProbOne ) { Gia_ManForEachObj( pAig, pObj, i ) pSwitching[i] = Gia_ManSwiComputeProbOne( p->pData1[i], pPars->nWords*(pPars->nIters-pPars->nPref) ); Gia_ManForEachCo( pAig, pObj, i ) { if ( Gia_ObjFaninC0(pObj) ) pSwitching[Gia_ObjId(pAig,pObj)] = (float)1.0-pSwitching[Gia_ObjId(pAig,Gia_ObjFanin0(pObj))]; else pSwitching[Gia_ObjId(pAig,pObj)] = pSwitching[Gia_ObjId(pAig,Gia_ObjFanin0(pObj))]; } } else if ( pPars->fProbTrans ) { Gia_ManForEachObj( pAig, pObj, i ) pSwitching[i] = Gia_ManSwiComputeProbOne( p->pData1[i], pPars->nWords*(pPars->nIters-pPars->nPref) ); } else { Gia_ManForEachObj( pAig, pObj, i ) pSwitching[i] = Gia_ManSwiComputeSwitching( p->pData1[i], pPars->nWords*(pPars->nIters-pPars->nPref) ); } /* printf( "PI: " ); Gia_ManForEachPi( pAig, pObj, i ) printf( "%d=%d (%f) ", i, p->pData1[Gia_ObjId(pAig,pObj)], pSwitching[Gia_ObjId(pAig,pObj)] ); printf( "\n" ); printf( "LO: " ); Gia_ManForEachRo( pAig, pObj, i ) printf( "%d=%d (%f) ", i, p->pData1[Gia_ObjId(pAig,pObj)], pSwitching[Gia_ObjId(pAig,pObj)] ); printf( "\n" ); printf( "PO: " ); Gia_ManForEachPo( pAig, pObj, i ) printf( "%d=%d (%f) ", i, p->pData1[Gia_ObjId(pAig,pObj)], pSwitching[Gia_ObjId(pAig,pObj)] ); printf( "\n" ); printf( "LI: " ); Gia_ManForEachRi( pAig, pObj, i ) printf( "%d=%d (%f) ", i, p->pData1[Gia_ObjId(pAig,pObj)], pSwitching[Gia_ObjId(pAig,pObj)] ); printf( "\n" ); */ Gia_ManSwiDelete( p ); return vSwitching; } /**Function************************************************************* Synopsis [Computes probability of switching (or of being 1).] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Vec_Int_t * Gia_ManComputeSwitchProbs( Gia_Man_t * pGia, int nFrames, int nPref, int fProbOne ) { Gia_ParSwi_t Pars, * pPars = &Pars; // set the default parameters Gia_ManSetDefaultParamsSwi( pPars ); // override some of the defaults pPars->nIters = nFrames; // set number of total timeframes if ( Abc_FrameReadFlag("seqsimframes") ) pPars->nIters = atoi( Abc_FrameReadFlag("seqsimframes") ); pPars->nPref = nPref; // set number of first timeframes to skip // decide what should be computed if ( fProbOne ) { // if the user asked to compute propability of 1, we do not need transition information pPars->fProbOne = 1; // enable computing probabiblity of being one pPars->fProbTrans = 0; // disable computing transition probability } else { // if the user asked for transition propabability, we do not need to compute probability of 1 pPars->fProbOne = 0; // disable computing probabiblity of being one pPars->fProbTrans = 1; // enable computing transition probability } // perform the computation of switching activity return Gia_ManSwiSimulate( pGia, pPars ); } Vec_Int_t * Saig_ManComputeSwitchProbs( Aig_Man_t * pAig, int nFrames, int nPref, int fProbOne ) { Vec_Int_t * vSwitching, * vResult; Gia_Man_t * p; Aig_Obj_t * pObj; int i; // translate AIG into the intermediate form (takes care of choices if present!) p = Gia_ManFromAigSwitch( pAig ); // perform the computation of switching activity vSwitching = Gia_ManComputeSwitchProbs( p, nFrames, nPref, fProbOne ); // transfer the computed result to the original AIG vResult = Vec_IntStart( Aig_ManObjNumMax(pAig) ); Aig_ManForEachObj( pAig, pObj, i ) { // if ( Aig_ObjIsCo(pObj) ) // printf( "%d=%f\n", i, Abc_Int2Float( Vec_IntEntry(vSwitching, Abc_Lit2Var(pObj->iData)) ) ); Vec_IntWriteEntry( vResult, i, Vec_IntEntry(vSwitching, Abc_Lit2Var(pObj->iData)) ); } // delete intermediate results Vec_IntFree( vSwitching ); Gia_ManStop( p ); return vResult; } /**Function************************************************************* Synopsis [Computes probability of switching (or of being 1).] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ float Gia_ManEvaluateSwitching( Gia_Man_t * p ) { Gia_Obj_t * pObj; float SwitchTotal = 0.0; int i; assert( p->pSwitching ); ABC_FREE( p->pRefs ); Gia_ManCreateRefs( p ); Gia_ManForEachObj( p, pObj, i ) SwitchTotal += (float)Gia_ObjRefNum(p, pObj) * p->pSwitching[i] / 255; return SwitchTotal; } /**Function************************************************************* Synopsis [Computes probability of switching (or of being 1).] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ /* float Gia_ManComputeSwitching( Gia_Man_t * p, int nFrames, int nPref, int fProbOne ) { Gia_Man_t * pDfs; Gia_Obj_t * pObj, * pObjDfs; Vec_Int_t * vSwitching; float * pSwitching, Switch, SwitchTotal = 0.0; int i; // derives the DFS ordered AIG if ( Gia_ManHasMapping(p) ) Gia_ManSetRefsMapped(p); else Gia_ManCreateRefs( p ); // pDfs = Gia_ManDupOrderDfs( p ); pDfs = Gia_ManDup( p ); assert( Gia_ManObjNum(pDfs) == Gia_ManObjNum(p) ); // perform the computation of switching activity vSwitching = Gia_ManComputeSwitchProbs( pDfs, nFrames, nPref, fProbOne ); // transfer the computed result to the original AIG ABC_FREE( p->pSwitching ); p->pSwitching = ABC_CALLOC( unsigned char, Gia_ManObjNum(p) ); pSwitching = (float *)vSwitching->pArray; Gia_ManForEachObj( p, pObj, i ) { pObjDfs = Gia_ObjFromLit( pDfs, pObj->Value ); Switch = pSwitching[ Gia_ObjId(pDfs, pObjDfs) ]; p->pSwitching[i] = (char)((Switch >= 1.0) ? 255 : (int)((0.002 + Switch) * 255)); // 0.00196 = (1/255)/2 if ( Gia_ObjIsCi(pObj) || (Gia_ObjIsAnd(pObj) && (!Gia_ManHasMapping(p) || Gia_ObjIsLut(p, i))) ) { SwitchTotal += (float)Gia_ObjRefNum(p, pObj) * p->pSwitching[i] / 255; // printf( "%d = %.2f\n", i, (float)Gia_ObjRefNum(p, pObj) * p->pSwitching[i] / 255 ); } } Vec_IntFree( vSwitching ); Gia_ManStop( pDfs ); return SwitchTotal; } */ float Gia_ManComputeSwitching( Gia_Man_t * p, int nFrames, int nPref, int fProbOne ) { Vec_Int_t * vSwitching = Gia_ManComputeSwitchProbs( p, nFrames, nPref, fProbOne ); float * pSwi = (float *)Vec_IntArray(vSwitching), SwiTotal = 0; Gia_Obj_t * pObj; int i, k, iFan; if ( Gia_ManHasMapping(p) ) { Gia_ManForEachLut( p, i ) Gia_LutForEachFanin( p, i, iFan, k ) SwiTotal += pSwi[iFan]; } else { Gia_ManForEachAnd( p, pObj, i ) SwiTotal += pSwi[Gia_ObjFaninId0(pObj, i)] + pSwi[Gia_ObjFaninId1(pObj, i)]; } Vec_IntFree( vSwitching ); return SwiTotal; } /**Function************************************************************* Synopsis [Determine probability of being 1 at the outputs.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Vec_Flt_t * Gia_ManPrintOutputProb( Gia_Man_t * p ) { Vec_Flt_t * vSimData; Gia_Man_t * pDfs = Gia_ManDup( p ); assert( Gia_ManObjNum(pDfs) == Gia_ManObjNum(p) ); vSimData = (Vec_Flt_t *)Gia_ManComputeSwitchProbs( pDfs, (Gia_ManRegNum(p) ? 16 : 1), 0, 1 ); Gia_ManStop( pDfs ); return vSimData; } //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// ABC_NAMESPACE_IMPL_END