#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "misc/vec/vec.h"
#include "misc/vec/vecWec.h"
#include "misc/util/utilCex.h"

Include dependency graph for gia.h:

Classes
struct	Gia_Rpr_t_

struct	Gia_Plc_t_

struct	Gia_Obj_t_

struct	Gia_Man_t_

struct	Gps_Par_t_

struct	Emb_Par_t_

struct	Gia_ParFra_t_

struct	Gia_ParSim_t_

struct	Gia_ManSim_t_

struct	Jf_Par_t_

Macros
#define	GIA_NONE 0x1FFFFFFF
	INCLUDES ///.

#define	GIA_VOID 0x0FFFFFFF

#define	GIA_ZER 1

#define	GIA_ONE 2

#define	GIA_UND 3

#define	Gia_ManForEachConst(p, i)

#define	Gia_ManForEachClass(p, i)

#define	Gia_ManForEachClass0(p, i)

#define	Gia_ManForEachClassReverse(p, i)

#define	Gia_ClassForEachObj(p, i, iObj)

#define	Gia_ClassForEachObj1(p, i, iObj)

#define	Gia_ClassForEachObjStart(p, i, iObj, Start)

#define	Gia_ObjForEachFanoutStatic(p, pObj, pFanout, i)

#define	Gia_ObjForEachFanoutStaticId(p, Id, FanId, i)

#define	Gia_ObjForEachFanoutStaticIndex(p, Id, FanId, i, Index)

#define	Gia_ManForEachLut(p, i)

#define	Gia_ManForEachLutReverse(p, i)

#define	Gia_LutForEachFanin(p, i, iFan, k)

#define	Gia_LutForEachFaninIndex(p, i, iFan, k, Index)

#define	Gia_LutForEachFaninObj(p, i, pFanin, k)

#define	Gia_ManForEachLut2(p, i)

#define	Gia_ManForEachLut2Reverse(p, i)

#define	Gia_ManForEachLut2Vec(vIds, p, vVec, iObj, i)

#define	Gia_ManForEachLut2VecReverse(vIds, p, vVec, iObj, i)

#define	Gia_LutForEachFanin2(p, i, iFan, k)

#define	Gia_LutForEachFanout2(p, i, iFan, k)

#define	Gia_ManForEachCell(p, i)

#define	Gia_CellForEachFanin(p, i, iFanLit, k)

#define	Gia_ManForEachObj(p, pObj, i)
	MACRO DEFINITIONS ///.

#define	Gia_ManForEachObj1(p, pObj, i)

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

#define	Gia_ManForEachObjVecStart(vVec, p, pObj, i, Start)

#define	Gia_ManForEachObjVecStop(vVec, p, pObj, i, Stop)

#define	Gia_ManForEachObjVecStartStop(vVec, p, pObj, i, Start, Stop)

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

#define	Gia_ManForEachObjVecLit(vVec, p, pObj, fCompl, i)

#define	Gia_ManForEachObjReverse(p, pObj, i)

#define	Gia_ManForEachObjReverse1(p, pObj, i)

#define	Gia_ManForEachBuf(p, pObj, i)

#define	Gia_ManForEachBufId(p, i)

#define	Gia_ManForEachAnd(p, pObj, i)

#define	Gia_ManForEachAndId(p, i)

#define	Gia_ManForEachMuxId(p, i)

#define	Gia_ManForEachCand(p, pObj, i)

#define	Gia_ManForEachAndReverse(p, pObj, i)

#define	Gia_ManForEachAndReverseId(p, i)

#define	Gia_ManForEachMux(p, pObj, i)

#define	Gia_ManForEachCi(p, pObj, i)

#define	Gia_ManForEachCiId(p, Id, i)

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

#define	Gia_ManForEachCiReverse(p, pObj, i)

#define	Gia_ManForEachCo(p, pObj, i)

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

#define	Gia_ManForEachCoId(p, Id, i)

#define	Gia_ManForEachCoReverse(p, pObj, i)

#define	Gia_ManForEachCoDriver(p, pObj, i)

#define	Gia_ManForEachCoDriverId(p, DriverId, i)

#define	Gia_ManForEachPi(p, pObj, i)

#define	Gia_ManForEachPo(p, pObj, i)

#define	Gia_ManForEachRo(p, pObj, i)

#define	Gia_ManForEachRi(p, pObj, i)

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

#define	Gia_ManForEachRoToRiVec(vRoIds, p, pObj, i)

#define	Gia_ManForEachObjWithBoxes(p, pObj, i)

#define	Gia_ManForEachObjReverseWithBoxes(p, pObj, i)

#define	Gia_ManForEachCiIdWithBoxes(p, Id, i)

#define	Gia_ManForEachCoWithBoxes(p, pObj, i)

Typedefs
typedef struct Gia_MmFixed_t_	Gia_MmFixed_t
	BASIC TYPES ///.

typedef struct Gia_MmFlex_t_	Gia_MmFlex_t

typedef struct Gia_MmStep_t_	Gia_MmStep_t

typedef struct Gia_Dat_t_	Gia_Dat_t

typedef struct Gia_Rpr_t_	Gia_Rpr_t

typedef struct Gia_Plc_t_	Gia_Plc_t

typedef struct Gia_Obj_t_	Gia_Obj_t

typedef struct Gia_Man_t_	Gia_Man_t

typedef struct Gps_Par_t_	Gps_Par_t

typedef struct Emb_Par_t_	Emb_Par_t

typedef struct Gia_ParFra_t_	Gia_ParFra_t

typedef struct Gia_ParSim_t_	Gia_ParSim_t

typedef struct Gia_ManSim_t_	Gia_ManSim_t

typedef struct Jf_Par_t_	Jf_Par_t

typedef struct Cbs_Man_t_	Cbs_Man_t

typedef struct Gia_ChMan_t_	Gia_ChMan_t

typedef struct Gia_ManMin_t_	Gia_ManMin_t

typedef struct Gia_Man2Min_t_	Gia_Man2Min_t

typedef struct Tas_Man_t_	Tas_Man_t

typedef struct Bnd_Man_t_	Bnd_Man_t

Functions
void	Gia_ObjAddFanout (Gia_Man_t p, Gia_Obj_t pObj, Gia_Obj_t *pFanout)

void	Gia_ManQuantSetSuppAnd (Gia_Man_t p, Gia_Obj_t pObj)

void	Gia_ManBuiltInSimPerform (Gia_Man_t *p, int iObj)

int	Gia_FileSize (char *pFileName)
	FUNCTION DECLARATIONS ///.

Gia_Man_t *	Gia_AigerReadFromMemory (char *pContents, int nFileSize, int fGiaSimple, int fSkipStrash, int fCheck)

Gia_Man_t *	Gia_AigerRead (char *pFileName, int fGiaSimple, int fSkipStrash, int fCheck)

void	Gia_AigerWrite (Gia_Man_t p, char pFileName, int fWriteSymbols, int fCompact, int fWriteNewLine)

void	Gia_AigerWriteS (Gia_Man_t p, char pFileName, int fWriteSymbols, int fCompact, int fWriteNewLine, int fSkipComment)

void	Gia_DumpAiger (Gia_Man_t p, char pFilePrefix, int iFileNum, int nFileNumDigits)

Vec_Str_t *	Gia_AigerWriteIntoMemoryStr (Gia_Man_t *p)

Vec_Str_t *	Gia_AigerWriteIntoMemoryStrPart (Gia_Man_t p, Vec_Int_t vCis, Vec_Int_t vAnds, Vec_Int_t vCos, int nRegs)

void	Gia_AigerWriteSimple (Gia_Man_t pInit, char pFileName)

Gia_Man_t *	Gia_ManBalance (Gia_Man_t *p, int fSimpleAnd, int fStrict, int fVerbose)

Gia_Man_t *	Gia_ManAreaBalance (Gia_Man_t *p, int fSimpleAnd, int nNewNodesMax, int fVerbose, int fVeryVerbose)

Gia_Man_t *	Gia_ManAigSyn2 (Gia_Man_t *p, int fOldAlgo, int fCoarsen, int fCutMin, int nRelaxRatio, int fDelayMin, int fVerbose, int fVeryVerbose)

Gia_Man_t *	Gia_ManAigSyn3 (Gia_Man_t *p, int fVerbose, int fVeryVerbose)

Gia_Man_t *	Gia_ManAigSyn4 (Gia_Man_t *p, int fVerbose, int fVeryVerbose)

unsigned *	Gia_ManConvertAigToTruth (Gia_Man_t p, Gia_Obj_t pRoot, Vec_Int_t vLeaves, Vec_Int_t vTruth, Vec_Int_t *vVisited)

Gia_Man_t *	Gia_ManPerformBidec (Gia_Man_t *p, int fVerbose)

int	Gia_ManVerifyCex (Gia_Man_t pAig, Abc_Cex_t p, int fDualOut)
	DECLARATIONS ///.

int	Gia_ManFindFailedPoCex (Gia_Man_t pAig, Abc_Cex_t p, int nOutputs)

int	Gia_ManSetFailedPoCex (Gia_Man_t pAig, Abc_Cex_t p)

void	Gia_ManCounterExampleValueStart (Gia_Man_t pGia, Abc_Cex_t pCex)

void	Gia_ManCounterExampleValueStop (Gia_Man_t *pGia)

int	Gia_ManCounterExampleValueLookup (Gia_Man_t *pGia, int Id, int iFrame)

Abc_Cex_t *	Gia_ManCexExtendToIncludeCurrentStates (Gia_Man_t p, Abc_Cex_t pCex)

Abc_Cex_t *	Gia_ManCexExtendToIncludeAllObjects (Gia_Man_t p, Abc_Cex_t pCex)

Vec_Int_t *	Cbs_ManSolveMiter (Gia_Man_t pGia, int nConfs, Vec_Str_t *pvStatus, int fVerbose)

Cbs_Man_t *	Cbs_ManAlloc (Gia_Man_t *pGia)

void	Cbs_ManStop (Cbs_Man_t *p)

int	Cbs_ManSolve (Cbs_Man_t p, Gia_Obj_t pObj)

int	Cbs_ManSolve2 (Cbs_Man_t p, Gia_Obj_t pObj, Gia_Obj_t *pObj2)

Vec_Int_t *	Cbs_ManSolveMiterNc (Gia_Man_t pGia, int nConfs, Vec_Str_t *pvStatus, int f0Proved, int fVerbose)

void	Cbs_ManSetConflictNum (Cbs_Man_t *p, int Num)

Vec_Int_t *	Cbs_ReadModel (Cbs_Man_t *p)

Vec_Int_t *	Tas_ManSolveMiterNc (Gia_Man_t pGia, int nConfs, Vec_Str_t *pvStatus, int fVerbose)

void	Gia_ManPrintFanio (Gia_Man_t *pGia, int nNodes)

Gia_Man_t *	Gia_ManDupCof (Gia_Man_t *p, int iVar)

Gia_Man_t *	Gia_ManDupCofAllInt (Gia_Man_t p, Vec_Int_t vSigs, int fVerbose)

Gia_Man_t *	Gia_ManDupCofAll (Gia_Man_t *p, int nFanLim, int fVerbose)

int	Gia_ResubVarNum (Vec_Int_t *vResub)
	FUNCTION DEFINITIONS ///.

word	Gia_ResubToTruth6 (Vec_Int_t *vResub)

int	Gia_ManEvalSolutionOne (Gia_Man_t p, Vec_Wrd_t vSims, Vec_Wrd_t vIsfs, Vec_Int_t vCands, Vec_Int_t *vSet, int nWords, int fVerbose)

Vec_Int_t *	Gia_ManDeriveSolutionOne (Gia_Man_t p, Vec_Wrd_t vSims, Vec_Wrd_t vIsfs, Vec_Int_t vCands, Vec_Int_t *vSet, int nWords, int Type)

void	Gia_ManCollectCis (Gia_Man_t p, int pNodes, int nNodes, Vec_Int_t *vSupp)

void	Gia_ManCollectAnds_rec (Gia_Man_t p, int iObj, Vec_Int_t vNodes)

void	Gia_ManCollectAnds (Gia_Man_t p, int pNodes, int nNodes, Vec_Int_t vNodes, Vec_Int_t vLeaves)

Vec_Int_t *	Gia_ManCollectAndsAll (Gia_Man_t *p)

Vec_Int_t *	Gia_ManCollectNodesCis (Gia_Man_t p, int pNodes, int nNodes)

int	Gia_ManSuppSize (Gia_Man_t p, int pNodes, int nNodes)

int	Gia_ManConeSize (Gia_Man_t p, int pNodes, int nNodes)

Vec_Vec_t *	Gia_ManLevelize (Gia_Man_t *p)

Vec_Wec_t *	Gia_ManLevelizeR (Gia_Man_t *p)

Vec_Int_t *	Gia_ManOrderReverse (Gia_Man_t *p)

void	Gia_ManCollectTfi (Gia_Man_t p, Vec_Int_t vRoots, Vec_Int_t *vNodes)

void	Gia_ManCollectTfo (Gia_Man_t p, Vec_Int_t vRoots, Vec_Int_t *vNodes)

void	Gia_ManDupRemapLiterals (Vec_Int_t vLits, Gia_Man_t p)
	FUNCTION DEFINITIONS ///.

void	Gia_ManDupRemapEquiv (Gia_Man_t pNew, Gia_Man_t p)

Gia_Man_t *	Gia_ManDupOrderDfs (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupOrderDfsChoices (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupOrderDfsReverse (Gia_Man_t *p, int fRevFans, int fRevOuts)

Gia_Man_t *	Gia_ManDupOutputGroup (Gia_Man_t *p, int iOutStart, int iOutStop)

Gia_Man_t *	Gia_ManDupOutputVec (Gia_Man_t p, Vec_Int_t vOutPres)

Gia_Man_t *	Gia_ManDupSelectedOutputs (Gia_Man_t p, Vec_Int_t vOutsLeft)

Gia_Man_t *	Gia_ManDupOrderAiger (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupLastPis (Gia_Man_t *p, int nLastPis)

Gia_Man_t *	Gia_ManDupFlip (Gia_Man_t p, int pInitState)

Gia_Man_t *	Gia_ManDupCycled (Gia_Man_t pAig, Abc_Cex_t pCex, int nFrames)

Gia_Man_t *	Gia_ManDup (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupNoBuf (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupMap (Gia_Man_t p, Vec_Int_t vMap)

Gia_Man_t *	Gia_ManDup2 (Gia_Man_t p1, Gia_Man_t p2)

Gia_Man_t *	Gia_ManDupWithAttributes (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupRemovePis (Gia_Man_t *p, int nRemPis)

Gia_Man_t *	Gia_ManDupZero (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupPerm (Gia_Man_t p, Vec_Int_t vPiPerm)

Gia_Man_t *	Gia_ManDupPermFlop (Gia_Man_t p, Vec_Int_t vFfPerm)

Gia_Man_t *	Gia_ManDupPermFlopGap (Gia_Man_t p, Vec_Int_t vFfPerm)

void	Gia_ManDupAppend (Gia_Man_t p, Gia_Man_t pTwo)

void	Gia_ManDupAppendShare (Gia_Man_t p, Gia_Man_t pTwo)

Gia_Man_t *	Gia_ManDupAppendNew (Gia_Man_t pOne, Gia_Man_t pTwo)

Gia_Man_t *	Gia_ManDupAppendCones (Gia_Man_t p, Gia_Man_t *ppCones, int nCones, int fOnlyRegs)

Gia_Man_t *	Gia_ManDupSelf (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupFlopClass (Gia_Man_t *p, int iClass)

Gia_Man_t *	Gia_ManDupMarked (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupTimes (Gia_Man_t *p, int nTimes)

Gia_Man_t *	Gia_ManDupDfs (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupDfsOnePo (Gia_Man_t *p, int iPo)

Gia_Man_t *	Gia_ManDupDfsRehash (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupCofactorVar (Gia_Man_t *p, int iVar, int Value)

Gia_Man_t *	Gia_ManDupCofactorObj (Gia_Man_t *p, int iObj, int Value)

Gia_Man_t *	Gia_ManDupMux (int iVar, Gia_Man_t pCof1, Gia_Man_t pCof0)

Gia_Man_t *	Gia_ManDupBlock (Gia_Man_t *p, int nBlock)

Gia_Man_t *	Gia_ManDupExist (Gia_Man_t *p, int iVar)

Gia_Man_t *	Gia_ManDupUniv (Gia_Man_t *p, int iVar)

Gia_Man_t *	Gia_ManDupDfsSkip (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupDfsCone (Gia_Man_t p, Gia_Obj_t pObj)

Gia_Man_t *	Gia_ManDupConeSupp (Gia_Man_t p, int iLit, Vec_Int_t vCiIds)

int	Gia_ManDupConeBack (Gia_Man_t p, Gia_Man_t pNew, Vec_Int_t *vCiIds)

int	Gia_ManDupConeBackObjs (Gia_Man_t p, Gia_Man_t pNew, Vec_Int_t *vObjs)

Gia_Man_t *	Gia_ManDupDfsNode (Gia_Man_t p, Gia_Obj_t pObj)

Gia_Man_t *	Gia_ManDupDfsLitArray (Gia_Man_t p, Vec_Int_t vLits)

Gia_Man_t *	Gia_ManDupTrimmed (Gia_Man_t *p, int fTrimCis, int fTrimCos, int fDualOut, int OutValue)

Gia_Man_t *	Gia_ManDupOntop (Gia_Man_t p, Gia_Man_t p2)

Gia_Man_t *	Gia_ManDupWithNewPo (Gia_Man_t p1, Gia_Man_t p2)

Gia_Man_t *	Gia_ManDupDfsCiMap (Gia_Man_t p, int pCi2Lit, Vec_Int_t *vLits)

Gia_Man_t *	Gia_ManPermuteInputs (Gia_Man_t *p, int nPpis, int nExtra)

Gia_Man_t *	Gia_ManDupDfsClasses (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupTopAnd (Gia_Man_t *p, int fVerbose)

Gia_Man_t *	Gia_ManMiter (Gia_Man_t pAig0, Gia_Man_t pAig1, int nInsDup, int fDualOut, int fSeq, int fImplic, int fVerbose)

Gia_Man_t *	Gia_ManMiterInverse (Gia_Man_t pBot, Gia_Man_t pTop, int fDualOut, int fVerbose)

Gia_Man_t *	Gia_ManDupAndOr (Gia_Man_t *p, int nOuts, int fUseOr, int fCompl)

Gia_Man_t *	Gia_ManDupZeroUndc (Gia_Man_t p, char pInit, int nNewPis, int fGiaSimple, int fVerbose)

Gia_Man_t *	Gia_ManMiter2 (Gia_Man_t p, char pInit, int fVerbose)

Gia_Man_t *	Gia_ManTransformMiter (Gia_Man_t *p)

Gia_Man_t *	Gia_ManTransformMiter2 (Gia_Man_t *p)

Gia_Man_t *	Gia_ManTransformToDual (Gia_Man_t *p)

Gia_Man_t *	Gia_ManTransformTwoWord2DualOutput (Gia_Man_t *p)

Gia_Man_t *	Gia_ManChoiceMiter (Vec_Ptr_t *vGias)

Gia_Man_t *	Gia_ManDupWithConstraints (Gia_Man_t p, Vec_Int_t vPoTypes)

Gia_Man_t *	Gia_ManDupCones (Gia_Man_t p, int pPos, int nPos, int fTrimPis)

Gia_Man_t *	Gia_ManDupAndCones (Gia_Man_t p, int pAnds, int nAnds, int fTrimPis)

Gia_Man_t *	Gia_ManDupAndConesLimit (Gia_Man_t p, int pAnds, int nAnds, int Level)

Gia_Man_t *	Gia_ManDupAndConesLimit2 (Gia_Man_t p, int pAnds, int nAnds, int Level)

Gia_Man_t *	Gia_ManDupOneHot (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupLevelized (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupFromVecs (Gia_Man_t p, Vec_Int_t vCis, Vec_Int_t vAnds, Vec_Int_t vCos, int nRegs)

Gia_Man_t *	Gia_ManDupSliced (Gia_Man_t *p, int nSuppMax)

Gia_Man_t *	Gia_ManDupDemiter (Gia_Man_t *p, int fVerbose)

Gia_Man_t *	Gia_ManDemiterToDual (Gia_Man_t *p)

int	Gia_ManDemiterDual (Gia_Man_t p, Gia_Man_t pp0, Gia_Man_t *pp1)

int	Gia_ManDemiterTwoWords (Gia_Man_t p, Gia_Man_t pp0, Gia_Man_t *pp1)

void	Gia_ManProdAdderGen (int nArgA, int nArgB, int Seed, int fSigned, int fCla)

Gia_ChMan_t *	Gia_ManDupChoicesStart (Gia_Man_t *pGia)

void	Gia_ManDupChoicesAdd (Gia_ChMan_t pMan, Gia_Man_t pGia)

Gia_Man_t *	Gia_ManDupChoicesFinish (Gia_ChMan_t *pMan)

void	Gia_ManEdgeFromArray (Gia_Man_t p, Vec_Int_t vArray)
	FUNCTION DEFINITIONS ///.

Vec_Int_t *	Gia_ManEdgeToArray (Gia_Man_t *p)

void	Gia_ManConvertPackingToEdges (Gia_Man_t *p)

int	Gia_ObjCheckEdge (Gia_Man_t *p, int iObj, int iNext)

int	Gia_ManEvalEdgeDelay (Gia_Man_t *p)

int	Gia_ManEvalEdgeCount (Gia_Man_t *p)

int	Gia_ManComputeEdgeDelay (Gia_Man_t *p, int fUseTwo)

int	Gia_ManComputeEdgeDelay2 (Gia_Man_t *p)

void	Gia_ManUpdateMapping (Gia_Man_t p, Vec_Int_t vNodes, Vec_Wec_t *vWin)

int	Gia_ManEvalWindow (Gia_Man_t p, Vec_Int_t vLeaves, Vec_Int_t vNodes, Vec_Wec_t vWin, Vec_Int_t *vTemp, int fUseTwo)

void	Gia_ManDetectSeqSignals (Gia_Man_t *p, int fSetReset, int fVerbose)

Gia_Man_t *	Gia_ManUnrollAndCofactor (Gia_Man_t *p, int nFrames, int nFanMax, int fVerbose)

Gia_Man_t *	Gia_ManRemoveEnables (Gia_Man_t *p)

void	Gia_ManOrigIdsInit (Gia_Man_t *p)
	DECLARATIONS ///.

void	Gia_ManOrigIdsStart (Gia_Man_t *p)

void	Gia_ManOrigIdsRemap (Gia_Man_t p, Gia_Man_t pNew)

Gia_Man_t *	Gia_ManOrigIdsReduce (Gia_Man_t p, Vec_Int_t vPairs)

Gia_Man_t *	Gia_ManComputeGiaEquivs (Gia_Man_t *pGia, int nConfs, int fVerbose)

void	Gia_ManEquivFixOutputPairs (Gia_Man_t *p)

int	Gia_ManCheckTopoOrder (Gia_Man_t *p)

int *	Gia_ManDeriveNexts (Gia_Man_t *p)

void	Gia_ManDeriveReprs (Gia_Man_t *p)

void	Gia_ManDeriveReprsFromSibls (Gia_Man_t *p)

int	Gia_ManEquivCountLits (Gia_Man_t *p)

int	Gia_ManEquivCountLitsAll (Gia_Man_t *p)

int	Gia_ManEquivCountClasses (Gia_Man_t *p)

void	Gia_ManEquivPrintOne (Gia_Man_t *p, int i, int Counter)

void	Gia_ManEquivPrintClasses (Gia_Man_t *p, int fVerbose, float Mem)

Gia_Man_t *	Gia_ManEquivReduce (Gia_Man_t *p, int fUseAll, int fDualOut, int fSkipPhase, int fVerbose)

Gia_Man_t *	Gia_ManEquivReduceAndRemap (Gia_Man_t *p, int fSeq, int fMiterPairs)

int	Gia_ManEquivSetColors (Gia_Man_t *p, int fVerbose)

Gia_Man_t *	Gia_ManSpecReduce (Gia_Man_t *p, int fDualOut, int fSynthesis, int fReduce, int fSkipSome, int fVerbose)

Gia_Man_t *	Gia_ManSpecReduceInit (Gia_Man_t p, Abc_Cex_t pInit, int nFrames, int fDualOut)

Gia_Man_t *	Gia_ManSpecReduceInitFrames (Gia_Man_t p, Abc_Cex_t pInit, int nFramesMax, int *pnFrames, int fDualOut, int nMinOutputs)

void	Gia_ManEquivTransform (Gia_Man_t *p, int fVerbose)

void	Gia_ManEquivImprove (Gia_Man_t *p)

Gia_Man_t *	Gia_ManEquivToChoices (Gia_Man_t *p, int nSnapshots)

int	Gia_ManCountChoiceNodes (Gia_Man_t *p)

int	Gia_ManCountChoices (Gia_Man_t *p)

int	Gia_ManFilterEquivsForSpeculation (Gia_Man_t pGia, char pName1, char *pName2, int fLatchA, int fLatchB)

int	Gia_ManFilterEquivsUsingParts (Gia_Man_t pGia, char pName1, char *pName2)

void	Gia_ManFilterEquivsUsingLatches (Gia_Man_t *pGia, int fFlopsOnly, int fFlopsWith, int fUseRiDrivers)

void	Gia_ManQuantSetSuppStart (Gia_Man_t *p)

void	Gia_ManQuantSetSuppZero (Gia_Man_t *p)

void	Gia_ManQuantSetSuppCi (Gia_Man_t p, Gia_Obj_t pObj)

void	Gia_ManQuantUpdateCiSupp (Gia_Man_t *p, int iObj)

int	Gia_ManQuantExist (Gia_Man_t p, int iLit, int(pFuncCiToKeep)(void , int), void pData)

void	Gia_ObjRemoveFanout (Gia_Man_t p, Gia_Obj_t pObj, Gia_Obj_t *pFanout)

void	Gia_ManFanoutStart (Gia_Man_t *p)
	FUNCTION DEFINITIONS ///.

void	Gia_ManFanoutStop (Gia_Man_t *p)

void	Gia_ManStaticFanoutStart (Gia_Man_t *p)

void	Gia_ManStaticFanoutStop (Gia_Man_t *p)

void	Gia_ManStaticMappingFanoutStart (Gia_Man_t p, Vec_Int_t *pvIndex)

void	For_ManExperiment (Gia_Man_t *pGia, int nIters, int fClustered, int fVerbose)

Gia_Man_t *	Gia_ManUnrollDup (Gia_Man_t p, Vec_Int_t vLimit)

Vec_Ptr_t *	Gia_ManUnrollAbs (Gia_Man_t *p, int nFrames)

void *	Gia_ManUnrollStart (Gia_Man_t pAig, Gia_ParFra_t pPars)

void *	Gia_ManUnrollAdd (void *pMan, int fMax)

void	Gia_ManUnrollStop (void *pMan)

int	Gia_ManUnrollLastLit (void *pMan)

void	Gia_ManFraSetDefaultParams (Gia_ParFra_t *p)

Gia_Man_t *	Gia_ManFrames (Gia_Man_t pAig, Gia_ParFra_t pPars)

Gia_Man_t *	Gia_ManFramesInitSpecial (Gia_Man_t *pAig, int nFrames, int fVerbose)

Gia_Man_t *	Gia_ManFront (Gia_Man_t *p)

void	Gia_ManFrontTest (Gia_Man_t *p)

Gia_Man_t *	Gia_ManPerformFx (Gia_Man_t *p, int nNewNodesMax, int LitCountMax, int fReverse, int fVerbose, int fVeryVerbose)

void	Gia_ManHashAlloc (Gia_Man_t *p)

void	Gia_ManHashStart (Gia_Man_t *p)

void	Gia_ManHashStop (Gia_Man_t *p)

int	Gia_ManHashXorReal (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManHashMuxReal (Gia_Man_t *p, int iLitC, int iLit1, int iLit0)

int	Gia_ManHashAnd (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManHashOr (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManHashXor (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManHashMux (Gia_Man_t *p, int iCtrl, int iData1, int iData0)

int	Gia_ManHashMaj (Gia_Man_t *p, int iData0, int iData1, int iData2)

int	Gia_ManHashAndTry (Gia_Man_t *p, int iLit0, int iLit1)

Gia_Man_t *	Gia_ManRehash (Gia_Man_t *p, int fAddStrash)

void	Gia_ManHashProfile (Gia_Man_t *p)

int	Gia_ManHashLookupInt (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManHashLookup (Gia_Man_t p, Gia_Obj_t p0, Gia_Obj_t *p1)

int	Gia_ManHashAndMulti (Gia_Man_t p, Vec_Int_t vLits)

int	Gia_ManHashAndMulti2 (Gia_Man_t p, Vec_Int_t vLits)

int	Gia_ManHashDualMiter (Gia_Man_t p, Vec_Int_t vOuts)

void	Gia_ManPrintOutputLutStats (Gia_Man_t *p)

void	Gia_ManPrintMappingStats (Gia_Man_t p, char pDumpFile)

void	Gia_ManPrintPackingStats (Gia_Man_t *p)

void	Gia_ManPrintLutStats (Gia_Man_t *p)

int	Gia_ManLutFaninCount (Gia_Man_t *p)

int	Gia_ManLutSizeMax (Gia_Man_t *p)

int	Gia_ManLutNum (Gia_Man_t *p)

int	Gia_ManLutLevel (Gia_Man_t p, int *ppLevels)

void	Gia_ManLutParams (Gia_Man_t p, int pnCurLuts, int pnCurEdges, int pnCurLevels)

void	Gia_ManSetRefsMapped (Gia_Man_t *p)

void	Gia_ManSetLutRefs (Gia_Man_t *p)

void	Gia_ManSetIfParsDefault (void *pIfPars)
	FUNCTION DEFINITIONS ///.

void	Gia_ManMappingVerify (Gia_Man_t *p)

void	Gia_ManTransferMapping (Gia_Man_t p, Gia_Man_t pGia)

void	Gia_ManTransferPacking (Gia_Man_t p, Gia_Man_t pGia)

void	Gia_ManTransferTiming (Gia_Man_t p, Gia_Man_t pGia)

Gia_Man_t *	Gia_ManPerformMapping (Gia_Man_t p, void pIfPars)

Gia_Man_t *	Gia_ManPerformSopBalance (Gia_Man_t *p, int nCutNum, int nRelaxRatio, int fVerbose)

Gia_Man_t *	Gia_ManPerformDsdBalance (Gia_Man_t *p, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose)

Gia_Man_t *	Gia_ManDupHashMapping (Gia_Man_t *p)

void	Jf_ManSetDefaultPars (Jf_Par_t *pPars)

Gia_Man_t *	Jf_ManPerformMapping (Gia_Man_t pGia, Jf_Par_t pPars)

Gia_Man_t *	Jf_ManDeriveCnf (Gia_Man_t *p, int fCnfObjIds)

Gia_Man_t *	Gia_ManIsoCanonicize (Gia_Man_t *p, int fVerbose)

Gia_Man_t *	Gia_ManIsoReduce (Gia_Man_t p, Vec_Ptr_t pvPosEquivs, Vec_Ptr_t *pvPiPerms, int fEstimate, int fDualOut, int fVerbose, int fVeryVerbose)

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

void	Lf_ManSetDefaultPars (Jf_Par_t *pPars)

Gia_Man_t *	Lf_ManPerformMapping (Gia_Man_t pGia, Jf_Par_t pPars)

Gia_Man_t *	Gia_ManPerformLfMapping (Gia_Man_t p, Jf_Par_t pPars, int fNormalized)

void	Gia_ManTestDistance (Gia_Man_t *p)

void	Gia_ManSolveProblem (Gia_Man_t pGia, Emb_Par_t pPars)

Gia_Man_t *	Gia_ManStart (int nObjsMax)
	FUNCTION DEFINITIONS ///.

void	Gia_ManStop (Gia_Man_t *p)

void	Gia_ManStopP (Gia_Man_t **p)

double	Gia_ManMemory (Gia_Man_t *p)

void	Gia_ManPrintStats (Gia_Man_t p, Gps_Par_t pPars)

void	Gia_ManPrintStatsShort (Gia_Man_t *p)

void	Gia_ManPrintMiterStatus (Gia_Man_t *p)

void	Gia_ManPrintStatsMiter (Gia_Man_t *p, int fVerbose)

void	Gia_ManSetRegNum (Gia_Man_t *p, int nRegs)

void	Gia_ManReportImprovement (Gia_Man_t p, Gia_Man_t pNew)

void	Gia_ManPrintNpnClasses (Gia_Man_t *p)

void	Gia_ManDumpVerilog (Gia_Man_t p, char pFileName, Vec_Int_t *vObjs, int fVerBufs, int fInter, int fInterComb, int fAssign, int fReverse)

void	Gia_ManDumpVerilogNand (Gia_Man_t p, char pFileName)

Gia_MmFixed_t *	Gia_MmFixedStart (int nEntrySize, int nEntriesMax)
	FUNCTION DEFINITIONS ///.

void	Gia_MmFixedStop (Gia_MmFixed_t *p, int fVerbose)

char *	Gia_MmFixedEntryFetch (Gia_MmFixed_t *p)

void	Gia_MmFixedEntryRecycle (Gia_MmFixed_t p, char pEntry)

void	Gia_MmFixedRestart (Gia_MmFixed_t *p)

int	Gia_MmFixedReadMemUsage (Gia_MmFixed_t *p)

int	Gia_MmFixedReadMaxEntriesUsed (Gia_MmFixed_t *p)

Gia_MmFlex_t *	Gia_MmFlexStart ()

void	Gia_MmFlexStop (Gia_MmFlex_t *p, int fVerbose)

char *	Gia_MmFlexEntryFetch (Gia_MmFlex_t *p, int nBytes)

void	Gia_MmFlexRestart (Gia_MmFlex_t *p)

int	Gia_MmFlexReadMemUsage (Gia_MmFlex_t *p)

Gia_MmStep_t *	Gia_MmStepStart (int nSteps)

void	Gia_MmStepStop (Gia_MmStep_t *p, int fVerbose)

char *	Gia_MmStepEntryFetch (Gia_MmStep_t *p, int nBytes)

void	Gia_MmStepEntryRecycle (Gia_MmStep_t p, char pEntry, int nBytes)

int	Gia_MmStepReadMemUsage (Gia_MmStep_t *p)

void	Mf_ManSetDefaultPars (Jf_Par_t *pPars)

Gia_Man_t *	Mf_ManPerformMapping (Gia_Man_t pGia, Jf_Par_t pPars)

void *	Mf_ManGenerateCnf (Gia_Man_t *pGia, int nLutSize, int fCnfObjIds, int fAddOrCla, int fMapping, int fVerbose)

Gia_Man_t *	Gia_ManReadMiniAig (char *pFileName, int fGiaSimple)

void	Gia_ManWriteMiniAig (Gia_Man_t pGia, char pFileName)

Gia_Man_t *	Gia_ManReadMiniLut (char *pFileName)

void	Gia_ManWriteMiniLut (Gia_Man_t pGia, char pFileName)

word *	Gia_ManCountFraction (Gia_Man_t p, Vec_Wrd_t vSimI, Vec_Int_t vSupp, int Thresh, int fVerbose, int pCare)

Vec_Int_t *	Gia_ManCollectSuppNew (Gia_Man_t *p, int iOut, int nOuts)

void	Gia_ManCountMuxXor (Gia_Man_t p, int pnMuxes, int *pnXors)
	DECLARATIONS ///.

void	Gia_ManPrintMuxStats (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupMuxes (Gia_Man_t *p, int Limit)

Gia_Man_t *	Gia_ManDupNoMuxes (Gia_Man_t *p, int fSkipBufs)

void	Gia_SatVerifyPattern (Gia_Man_t p, Gia_Obj_t pRoot, Vec_Int_t vCex, Vec_Int_t vVisit)

Gia_Man_t *	Gia_ManRetimeForward (Gia_Man_t *p, int nMaxIters, int fVerbose)

int	Sat_ManTest (Gia_Man_t pGia, Gia_Obj_t pObj, int nConfsMax)

int	Gia_ManSeqMarkUsed (Gia_Man_t *p)

int	Gia_ManCombMarkUsed (Gia_Man_t *p)

Gia_Man_t *	Gia_ManCleanup (Gia_Man_t *p)

Gia_Man_t *	Gia_ManCleanupOutputs (Gia_Man_t *p, int nOutputs)

Gia_Man_t *	Gia_ManSeqCleanup (Gia_Man_t *p)

Gia_Man_t *	Gia_ManSeqStructSweep (Gia_Man_t *p, int fConst, int fEquiv, int fVerbose)

void	Gia_ManShow (Gia_Man_t pMan, Vec_Int_t vBold, int fAdders, int fFadds, int fPath)

Gia_Man_t *	Gia_ManMapShrink4 (Gia_Man_t *p, int fKeepLevel, int fVerbose)
	FUNCTION DEFINITIONS ///.

Gia_Man_t *	Gia_ManMapShrink6 (Gia_Man_t *p, int nFanoutMax, int fKeepLevel, int fVerbose)

Gia_Man_t *	Gia_ManExtractWindow (Gia_Man_t *p, int LevelMax, int nTimeWindow, int fVerbose)

Gia_Man_t *	Gia_ManPerformSopBalanceWin (Gia_Man_t *p, int LevelMax, int nTimeWindow, int nCutNum, int nRelaxRatio, int fVerbose)

Gia_Man_t *	Gia_ManPerformDsdBalanceWin (Gia_Man_t *p, int LevelMax, int nTimeWindow, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose)

int *	Gia_SortFloats (float pArray, int pPerm, int nSize)

void	Gia_ManSimSetDefaultParams (Gia_ParSim_t *p)

int	Gia_ManSimSimulate (Gia_Man_t pAig, Gia_ParSim_t pPars)

unsigned *	Gia_SimDataExt (Gia_ManSim_t *p, int i)

unsigned *	Gia_SimDataCiExt (Gia_ManSim_t *p, int i)

unsigned *	Gia_SimDataCoExt (Gia_ManSim_t *p, int i)

void	Gia_ManSimInfoInit (Gia_ManSim_t *p)

void	Gia_ManSimInfoTransfer (Gia_ManSim_t *p)

void	Gia_ManSimulateRound (Gia_ManSim_t *p)

void	Gia_ManBuiltInSimStart (Gia_Man_t *p, int nWords, int nObjs)

int	Gia_ManBuiltInSimCheckOver (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManBuiltInSimCheckEqual (Gia_Man_t *p, int iLit0, int iLit1)

void	Gia_ManBuiltInSimResimulateCone (Gia_Man_t *p, int iLit0, int iLit1)

void	Gia_ManBuiltInSimResimulate (Gia_Man_t *p)

int	Gia_ManBuiltInSimAddPat (Gia_Man_t p, Vec_Int_t vPat)

void	Gia_ManIncrSimStart (Gia_Man_t *p, int nWords, int nObjs)

void	Gia_ManIncrSimSet (Gia_Man_t p, Vec_Int_t vObjLits)

int	Gia_ManIncrSimCheckOver (Gia_Man_t *p, int iLit0, int iLit1)

int	Gia_ManIncrSimCheckEqual (Gia_Man_t *p, int iLit0, int iLit1)

Vec_Wrd_t *	Gia_ManSimPatSim (Gia_Man_t *p)

Vec_Wrd_t *	Gia_ManSimPatSimOut (Gia_Man_t pGia, Vec_Wrd_t vSimsPi, int fOuts)

void	Gia_ManSim2ArrayOne (Vec_Wrd_t vSimsPi, Vec_Int_t vRes)

Vec_Wec_t *	Gia_ManSim2Array (Vec_Ptr_t *vSims)

Vec_Wrd_t *	Gia_ManArray2SimOne (Vec_Int_t *vRes)

Vec_Ptr_t *	Gia_ManArray2Sim (Vec_Wec_t *vRes)

void	Gia_ManPtrWrdDumpBin (char pFileName, Vec_Ptr_t p, int fVerbose)

Vec_Ptr_t *	Gia_ManPtrWrdReadBin (char *pFileName, int fVerbose)

Vec_Str_t *	Gia_ManComputeRange (Gia_Man_t *p)

float	Gia_ManDelayTraceLut (Gia_Man_t *p)

float	Gia_ManDelayTraceLutPrint (Gia_Man_t *p, int fVerbose)

Gia_Man_t *	Gia_ManSpeedup (Gia_Man_t *p, int Percentage, int Degree, int fVerbose, int fVeryVerbose)

void	Gia_ManComputeOneWinStart (Gia_Man_t *p, int nAnds, int fReverse)

int	Gia_ManComputeOneWin (Gia_Man_t p, int iPivot, Vec_Int_t pvRoots, Vec_Int_t pvNodes, Vec_Int_t pvLeaves, Vec_Int_t *pvAnds)

void	Gia_ManStgPrint (FILE pFile, Vec_Int_t vLines, int nIns, int nOuts, int nStates)

Gia_Man_t *	Gia_ManStgRead (char *pFileName, int kHot, int fVerbose)

Gia_ManMin_t *	Gia_ManSuppStart (Gia_Man_t *pGia)
	DECLARATIONS ///.

void	Gia_ManSuppStop (Gia_ManMin_t *p)

int	Gia_ManSupportAnd (Gia_ManMin_t *p, int iLit0, int iLit1)

Gia_Man2Min_t *	Gia_Man2SuppStart (Gia_Man_t *pGia)

void	Gia_Man2SuppStop (Gia_Man2Min_t *p)

int	Gia_Man2SupportAnd (Gia_Man2Min_t *p, int iLit0, int iLit1)

Gia_Man_t *	Gia_ManFraigSweepSimple (Gia_Man_t p, void pPars)

Gia_Man_t *	Gia_ManSweepWithBoxes (Gia_Man_t p, void pParsC, void *pParsS, int fConst, int fEquiv, int fVerbose, int fVerbEquivs)

void	Gia_ManCheckIntegrityWithBoxes (Gia_Man_t *p)

Gia_Man_t *	Gia_SweeperStart (Gia_Man_t *p)

void	Gia_SweeperStop (Gia_Man_t *p)

int	Gia_SweeperIsRunning (Gia_Man_t *p)

void	Gia_SweeperPrintStats (Gia_Man_t *p)

void	Gia_SweeperSetConflictLimit (Gia_Man_t *p, int nConfMax)

void	Gia_SweeperSetRuntimeLimit (Gia_Man_t *p, int nSeconds)

Vec_Int_t *	Gia_SweeperGetCex (Gia_Man_t *p)

int	Gia_SweeperProbeCreate (Gia_Man_t *p, int iLit)

int	Gia_SweeperProbeDelete (Gia_Man_t *p, int ProbeId)

int	Gia_SweeperProbeUpdate (Gia_Man_t *p, int ProbeId, int iLitNew)

int	Gia_SweeperProbeLit (Gia_Man_t *p, int ProbeId)

Vec_Int_t *	Gia_SweeperCollectValidProbeIds (Gia_Man_t *p)

int	Gia_SweeperCondPop (Gia_Man_t *p)

void	Gia_SweeperCondPush (Gia_Man_t *p, int ProbeId)

Vec_Int_t *	Gia_SweeperCondVector (Gia_Man_t *p)

int	Gia_SweeperCondCheckUnsat (Gia_Man_t *p)

int	Gia_SweeperCheckEquiv (Gia_Man_t *p, int ProbeId1, int ProbeId2)

Gia_Man_t *	Gia_SweeperExtractUserLogic (Gia_Man_t p, Vec_Int_t vProbeIds, Vec_Ptr_t vInNames, Vec_Ptr_t vOutNames)

void	Gia_SweeperLogicDump (Gia_Man_t p, Vec_Int_t vProbeIds, int fDumpConds, char *pFileName)

Gia_Man_t *	Gia_SweeperCleanup (Gia_Man_t p, char pCommLime)

Vec_Int_t *	Gia_SweeperGraft (Gia_Man_t pDst, Vec_Int_t vProbes, Gia_Man_t *pSrc)

int	Gia_SweeperFraig (Gia_Man_t p, Vec_Int_t vProbeIds, char *pCommLime, int nWords, int nConfs, int fVerify, int fVerbose)

int	Gia_SweeperRun (Gia_Man_t p, Vec_Int_t vProbeIds, char *pCommLime, int fVerbose)

float	Gia_ManEvaluateSwitching (Gia_Man_t *p)

float	Gia_ManComputeSwitching (Gia_Man_t *p, int nFrames, int nPref, int fProbOne)

Vec_Int_t *	Gia_ManComputeSwitchProbs (Gia_Man_t *pGia, int nFrames, int nPref, int fProbOne)

Vec_Int_t *	Gia_ManComputeSwitchProbs2 (Gia_Man_t *pGia, int nFrames, int nPref, int fProbOne, int nRandPiFactor)

Vec_Flt_t *	Gia_ManPrintOutputProb (Gia_Man_t *p)

int	Gia_ManBoxNum (Gia_Man_t *p)
	DECLARATIONS ///.

int	Gia_ManRegBoxNum (Gia_Man_t *p)

int	Gia_ManNonRegBoxNum (Gia_Man_t *p)

int	Gia_ManBlackBoxNum (Gia_Man_t *p)

int	Gia_ManBoxCiNum (Gia_Man_t *p)

int	Gia_ManBoxCoNum (Gia_Man_t *p)

int	Gia_ManClockDomainNum (Gia_Man_t *p)

int	Gia_ManIsSeqWithBoxes (Gia_Man_t *p)

int	Gia_ManIsNormalized (Gia_Man_t *p)

Vec_Int_t *	Gia_ManOrderWithBoxes (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupNormalize (Gia_Man_t *p, int fHashMapping)

Gia_Man_t *	Gia_ManDupUnnormalize (Gia_Man_t *p)

Gia_Man_t *	Gia_ManDupUnshuffleInputs (Gia_Man_t *p)

int	Gia_ManLevelWithBoxes (Gia_Man_t *p)

int	Gia_ManLutLevelWithBoxes (Gia_Man_t *p)

void *	Gia_ManUpdateTimMan (Gia_Man_t p, Vec_Int_t vBoxPres)

void *	Gia_ManUpdateTimMan2 (Gia_Man_t p, Vec_Int_t vBoxesLeft, int nTermsDiff)

Gia_Man_t *	Gia_ManUpdateExtraAig (void pTime, Gia_Man_t pAig, Vec_Int_t *vBoxPres)

Gia_Man_t *	Gia_ManUpdateExtraAig2 (void pTime, Gia_Man_t pAig, Vec_Int_t *vBoxesLeft)

Gia_Man_t *	Gia_ManDupCollapse (Gia_Man_t p, Gia_Man_t pBoxes, Vec_Int_t *vBoxPres, int fSeq)

int	Gia_ManVerifyWithBoxes (Gia_Man_t pGia, int nBTLimit, int nTimeLim, int fSeq, int fDumpFiles, int fVerbose, char pFileSpec)

word	Gia_LutComputeTruth6 (Gia_Man_t p, int iObj, Vec_Wrd_t vTruths)

word	Gia_ObjComputeTruthTable6Lut (Gia_Man_t p, int iObj, Vec_Wrd_t vTemp)

word	Gia_ObjComputeTruthTable6 (Gia_Man_t p, Gia_Obj_t pObj, Vec_Int_t vSupp, Vec_Wrd_t vTruths)

word	Gia_ObjComputeTruth6Cis (Gia_Man_t p, int iLit, Vec_Int_t vSupp, Vec_Wrd_t *vTemp)

void	Gia_ObjCollectInternal (Gia_Man_t p, Gia_Obj_t pObj)

word *	Gia_ObjComputeTruthTable (Gia_Man_t p, Gia_Obj_t pObj)

void	Gia_ObjComputeTruthTableStart (Gia_Man_t *p, int nVarsMax)

void	Gia_ObjComputeTruthTableStop (Gia_Man_t *p)

word *	Gia_ObjComputeTruthTableCut (Gia_Man_t p, Gia_Obj_t pObj, Vec_Int_t *vLeaves)

Gia_Man_t *	Gia_ManReduceConst (Gia_Man_t *pAig, int fVerbose)

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_ManCleanLevels (Gia_Man_t *p, int Size)

void	Gia_ManCleanTruth (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)

int	Gia_ManLevelNum (Gia_Man_t *p)

int	Gia_ManLevelRNum (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)

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)

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_NodeMffcSize (Gia_Man_t p, Gia_Obj_t pNode)

int	Gia_NodeMffcSizeMark (Gia_Man_t p, Gia_Obj_t pNode)

int	Gia_NodeMffcSizeSupp (Gia_Man_t p, Gia_Obj_t pNode, 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 (Gia_Man_t p, Gia_Obj_t pObj)

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_ManPrintCone2 (Gia_Man_t p, Gia_Obj_t pObj)

void	Gia_ManInvertConstraints (Gia_Man_t *pAig)

void	Gia_ManInvertPos (Gia_Man_t *pAig)

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_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)

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

Gia_Man_t *	Gia_ManTtopt (Gia_Man_t *p, int nIns, int nOuts, int nRounds)

Gia_Man_t *	Gia_ManTtoptCare (Gia_Man_t p, int nIns, int nOuts, int nRounds, char pFileName, int nRarity)

Gia_Man_t *	Gia_ManTransductionBdd (Gia_Man_t pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t pExdc, int fNewLine, int nVerbose)

Gia_Man_t *	Gia_ManTransductionTt (Gia_Man_t pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t pExdc, int fNewLine, int nVerbose)

Gia_Man_t *	Gia_ManRrr (Gia_Man_t *pGia, int iSeed, int nWords, int nTimeout, int nSchedulerVerbose, int nPartitionerVerbose, int nOptimizerVerbose, int nAnalyzerVerbose, int nSimulatorVerbose, int nSatSolverVerbose, int fUseBddCspf, int fUseBddMspf, int nConflictLimit, int nSortType, int nOptimizerFlow, int nSchedulerFlow, int nPartitionType, int nDistance, int nJobs, int nThreads, int nPartitionSize, int nPartitionSizeMin, int fDeterministic, int nParallelPartitions, int fOptOnInsert, int fGreedy)

Tas_Man_t *	Tas_ManAlloc (Gia_Man_t *pAig, int nBTLimit)

void	Tas_ManStop (Tas_Man_t *p)

Vec_Int_t *	Tas_ReadModel (Tas_Man_t *p)

void	Tas_ManSatPrintStats (Tas_Man_t *p)

int	Tas_ManSolve (Tas_Man_t p, Gia_Obj_t pObj, Gia_Obj_t *pObj2)

int	Tas_ManSolveArray (Tas_Man_t p, Vec_Ptr_t vObjs)

Bnd_Man_t *	Bnd_ManStart (Gia_Man_t pSpec, Gia_Man_t pImpl, int fVerbose)

void	Bnd_ManStop ()

int	Bnd_ManGetNInternal ()

int	Bnd_ManGetNExtra ()

void	Bnd_ManMap (int iLit, int id, int spec)

void	Bnd_ManMerge (int id1, int id2, int phaseDiff)

void	Bnd_ManFinalizeMappings ()

void	Bnd_ManPrintMappings ()

Gia_Man_t *	Bnd_ManStackGias (Gia_Man_t pSpec, Gia_Man_t pImpl)

int	Bnd_ManCheckCoMerged (Gia_Man_t *p)

int	Bnd_ManCheckBound (Gia_Man_t *p, int fVerbose)

void	Bnd_ManFindBound (Gia_Man_t p, Gia_Man_t pImpl)

Gia_Man_t *	Bnd_ManGenSpecOut (Gia_Man_t *p)

Gia_Man_t *	Bnd_ManGenImplOut (Gia_Man_t *p)

Gia_Man_t *	Bnd_ManGenPatched (Gia_Man_t pOut, Gia_Man_t pSpec, Gia_Man_t *pPatch)

Gia_Man_t *	Bnd_ManGenPatched1 (Gia_Man_t pOut, Gia_Man_t pSpec)

Gia_Man_t *	Bnd_ManGenPatched2 (Gia_Man_t pImpl, Gia_Man_t pPatch, int fSkiptStrash, int fVerbose)

void	Bnd_ManSetEqOut (int eq)
	FUNCTION DEFINITIONS ///.

void	Bnd_ManSetEqRes (int eq)

void	Bnd_ManPrintStats ()

Gia_Man_t *	Bnd_ManCutBoundary (Gia_Man_t p, Vec_Int_t vEI, Vec_Int_t vEO, Vec_Bit_t vEI_phase, Vec_Bit_t *vEO_phase)

int	Gia_ObjCheckMffc (Gia_Man_t p, Gia_Obj_t pRoot, int Limit, Vec_Int_t vNodes, Vec_Int_t vLeaves, Vec_Int_t *vInners)

Macro Definition Documentation

◆ Gia_CellForEachFanin

#define Gia_CellForEachFanin	(	p,
		i,
		iFanLit,
		k )

Value:

for ( k = 0; k < Gia_ObjCellSize(p,i) && ((iFanLit = Gia_ObjCellFanins(p,i)[k]),1); k++ )

p

Cube * p

Definition exorList.c:222

Definition at line 1183 of file gia.h.

1183#define Gia_CellForEachFanin( p, i, iFanLit, k ) \

1184 for ( k = 0; k < Gia_ObjCellSize(p,i) && ((iFanLit = Gia_ObjCellFanins(p,i)[k]),1); k++ )

◆ Gia_ClassForEachObj

#define Gia_ClassForEachObj	(	p,
		i,
		iObj )

Value:

for ( assert(Gia_ObjIsHead(p, i) && i), iObj = i; iObj > 0; iObj = Gia_ObjNext(p, iObj) )

assert

#define assert(ex)

Definition util_old.h:213

Definition at line 1107 of file gia.h.

1107#define Gia_ClassForEachObj( p, i, iObj ) \

1108 for ( assert(Gia_ObjIsHead(p, i) && i), iObj = i; iObj > 0; iObj = Gia_ObjNext(p, iObj) )

◆ Gia_ClassForEachObj1

#define Gia_ClassForEachObj1	(	p,
		i,
		iObj )

Value:

for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, i); iObj > 0; iObj = Gia_ObjNext(p, iObj) )

Definition at line 1109 of file gia.h.

1109#define Gia_ClassForEachObj1( p, i, iObj ) \

1110 for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, i); iObj > 0; iObj = Gia_ObjNext(p, iObj) )

◆ Gia_ClassForEachObjStart

#define Gia_ClassForEachObjStart	(	p,
		i,
		iObj,
		Start )

Value:

for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, Start); iObj > 0; iObj = Gia_ObjNext(p, iObj) )

Definition at line 1111 of file gia.h.

1111#define Gia_ClassForEachObjStart( p, i, iObj, Start ) \

1112 for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, Start); iObj > 0; iObj = Gia_ObjNext(p, iObj) )

◆ Gia_LutForEachFanin

#define Gia_LutForEachFanin	(	p,
		i,
		iFan,
		k )

Value:

for ( k = 0; k < Gia_ObjLutSize(p,i) && ((iFan = Gia_ObjLutFanins(p,i)[k]),1); k++ )

Definition at line 1161 of file gia.h.

1161#define Gia_LutForEachFanin( p, i, iFan, k ) \

1162 for ( k = 0; k < Gia_ObjLutSize(p,i) && ((iFan = Gia_ObjLutFanins(p,i)[k]),1); k++ )

◆ Gia_LutForEachFanin2

#define Gia_LutForEachFanin2	(	p,
		i,
		iFan,
		k )

Value:

for ( k = 0; k < Gia_ObjLutSize2(p,i) && ((iFan = Gia_ObjLutFanin2(p,i,k)),1); k++ )

Definition at line 1176 of file gia.h.

1176#define Gia_LutForEachFanin2( p, i, iFan, k ) \

1177 for ( k = 0; k < Gia_ObjLutSize2(p,i) && ((iFan = Gia_ObjLutFanin2(p,i,k)),1); k++ )

◆ Gia_LutForEachFaninIndex

#define Gia_LutForEachFaninIndex	(	p,
		i,
		iFan,
		k,
		Index )

Value:

for ( k = 0; k < Gia_ObjLutSize(p,i) && (Index = Vec_IntEntry(p->vMapping, i)+1+k) && ((iFan = Vec_IntEntry(p->vMapping, Index)),1); k++ )

Definition at line 1163 of file gia.h.

1163#define Gia_LutForEachFaninIndex( p, i, iFan, k, Index ) \

1164 for ( k = 0; k < Gia_ObjLutSize(p,i) && (Index = Vec_IntEntry(p->vMapping, i)+1+k) && ((iFan = Vec_IntEntry(p->vMapping, Index)),1); k++ )

◆ Gia_LutForEachFaninObj

#define Gia_LutForEachFaninObj	(	p,
		i,
		pFanin,
		k )

Value:

for ( k = 0; k < Gia_ObjLutSize(p,i) && ((pFanin = Gia_ManObj(p, Gia_ObjLutFanins(p,i)[k])),1); k++ )

Definition at line 1165 of file gia.h.

1165#define Gia_LutForEachFaninObj( p, i, pFanin, k ) \

1166 for ( k = 0; k < Gia_ObjLutSize(p,i) && ((pFanin = Gia_ManObj(p, Gia_ObjLutFanins(p,i)[k])),1); k++ )

◆ Gia_LutForEachFanout2

#define Gia_LutForEachFanout2	(	p,
		i,
		iFan,
		k )

Value:

for ( k = 0; k < Gia_ObjLutFanoutNum2(p,i) && ((iFan = Gia_ObjLutFanout2(p,i,k)),1); k++ )

Definition at line 1178 of file gia.h.

1178#define Gia_LutForEachFanout2( p, i, iFan, k ) \

1179 for ( k = 0; k < Gia_ObjLutFanoutNum2(p,i) && ((iFan = Gia_ObjLutFanout2(p,i,k)),1); k++ )

◆ Gia_ManForEachAnd

#define Gia_ManForEachAnd	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsAnd(pObj) ) {} else

Definition at line 1214 of file gia.h.

1214#define Gia_ManForEachAnd( p, pObj, i ) \

1215 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsAnd(pObj) ) {} else

◆ Gia_ManForEachAndId

#define Gia_ManForEachAndId	(		p,
			i )

Value:

for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else

Definition at line 1216 of file gia.h.

1216#define Gia_ManForEachAndId( p, i ) \

1217 for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else

◆ Gia_ManForEachAndReverse

#define Gia_ManForEachAndReverse	(	p,
		pObj,
		i )

Value:

for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- ) if ( !Gia_ObjIsAnd(pObj) ) {} else

Definition at line 1222 of file gia.h.

1222#define Gia_ManForEachAndReverse( p, pObj, i ) \

1223 for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- ) if ( !Gia_ObjIsAnd(pObj) ) {} else

◆ Gia_ManForEachAndReverseId

#define Gia_ManForEachAndReverseId	(		p,
			i )

Value:

for ( i = p->nObjs - 1; (i > 0); i-- ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else

Definition at line 1224 of file gia.h.

1224#define Gia_ManForEachAndReverseId( p, i ) \

1225 for ( i = p->nObjs - 1; (i > 0); i-- ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else

◆ Gia_ManForEachBuf

#define Gia_ManForEachBuf	(	p,
		pObj,
		i )

Value:

for ( i = Gia_ManBufNum(p) ? 0 : p->nObjs; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsBuf(pObj) ) {} else

Definition at line 1210 of file gia.h.

1210#define Gia_ManForEachBuf( p, pObj, i ) \

1211 for ( i = Gia_ManBufNum(p) ? 0 : p->nObjs; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsBuf(pObj) ) {} else

◆ Gia_ManForEachBufId

#define Gia_ManForEachBufId	(		p,
			i )

Value:

for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsBuf(Gia_ManObj(p, i)) ) {} else

Definition at line 1212 of file gia.h.

1212#define Gia_ManForEachBufId( p, i ) \

1213 for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsBuf(Gia_ManObj(p, i)) ) {} else

◆ Gia_ManForEachCand

#define Gia_ManForEachCand	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsCand(pObj) ) {} else

Definition at line 1220 of file gia.h.

1220#define Gia_ManForEachCand( p, pObj, i ) \

1221 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsCand(pObj) ) {} else

◆ Gia_ManForEachCell

#define Gia_ManForEachCell	(		p,
			i )

Value:

for ( i = 2; i < 2*Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsCell(p, i) ) {} else

Definition at line 1181 of file gia.h.

1181#define Gia_ManForEachCell( p, i ) \

1182 for ( i = 2; i < 2*Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsCell(p, i) ) {} else

◆ Gia_ManForEachCi

#define Gia_ManForEachCi	(	p,
		pObj,
		i )

Value:

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

Definition at line 1228 of file gia.h.

1228#define Gia_ManForEachCi( p, pObj, i ) \

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

◆ Gia_ManForEachCiId

#define Gia_ManForEachCiId	(	p,
		Id,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(p->vCis)) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )

Definition at line 1230 of file gia.h.

1230#define Gia_ManForEachCiId( p, Id, i ) \

1231 for ( i = 0; (i < Vec_IntSize(p->vCis)) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )

◆ Gia_ManForEachCiIdWithBoxes

#define Gia_ManForEachCiIdWithBoxes	(	p,
		Id,
		i )

Value:

for ( i = 0; (i < p->iFirstNonPiId) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )

Definition at line 1265 of file gia.h.

1265#define Gia_ManForEachCiIdWithBoxes( p, Id, i ) \

1266 for ( i = 0; (i < p->iFirstNonPiId) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )

◆ Gia_ManForEachCiReverse

#define Gia_ManForEachCiReverse	(	p,
		pObj,
		i )

Value:

for ( i = Vec_IntSize(p->vCis) - 1; (i >= 0) && ((pObj) = Gia_ManCi(p, i)); i-- )

Definition at line 1234 of file gia.h.

1234#define Gia_ManForEachCiReverse( p, pObj, i ) \

1235 for ( i = Vec_IntSize(p->vCis) - 1; (i >= 0) && ((pObj) = Gia_ManCi(p, i)); i-- )

◆ Gia_ManForEachCiVec

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

Value:

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

Definition at line 1232 of file gia.h.

1232#define Gia_ManForEachCiVec( vVec, p, pObj, i ) \

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

◆ Gia_ManForEachClass

#define Gia_ManForEachClass	(		p,
			i )

Value:

for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else

Definition at line 1101 of file gia.h.

1101#define Gia_ManForEachClass( p, i ) \

1102 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else

◆ Gia_ManForEachClass0

#define Gia_ManForEachClass0	(		p,
			i )

Value:

for ( i = 0; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else

Definition at line 1103 of file gia.h.

1103#define Gia_ManForEachClass0( p, i ) \

1104 for ( i = 0; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else

◆ Gia_ManForEachClassReverse

#define Gia_ManForEachClassReverse	(		p,
			i )

Value:

for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsHead(p, i) ) {} else

Definition at line 1105 of file gia.h.

1105#define Gia_ManForEachClassReverse( p, i ) \

1106 for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsHead(p, i) ) {} else

◆ Gia_ManForEachCo

#define Gia_ManForEachCo	(	p,
		pObj,
		i )

Value:

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

Definition at line 1236 of file gia.h.

1236#define Gia_ManForEachCo( p, pObj, i ) \

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

◆ Gia_ManForEachCoDriver

#define Gia_ManForEachCoDriver	(	p,
		pObj,
		i )

Value:

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

Definition at line 1244 of file gia.h.

1244#define Gia_ManForEachCoDriver( p, pObj, i ) \

1245 for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ObjFanin0(Gia_ManCo(p, i))); i++ )

◆ Gia_ManForEachCoDriverId

#define Gia_ManForEachCoDriverId	(	p,
		DriverId,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(p->vCos)) && (((DriverId) = Gia_ObjFaninId0p(p, Gia_ManCo(p, i))), 1); i++ )

Definition at line 1246 of file gia.h.

1246#define Gia_ManForEachCoDriverId( p, DriverId, i ) \

1247 for ( i = 0; (i < Vec_IntSize(p->vCos)) && (((DriverId) = Gia_ObjFaninId0p(p, Gia_ManCo(p, i))), 1); i++ )

◆ Gia_ManForEachCoId

#define Gia_ManForEachCoId	(	p,
		Id,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((Id) = Gia_ObjId(p, Gia_ManCo(p, i))); i++ )

Definition at line 1240 of file gia.h.

1240#define Gia_ManForEachCoId( p, Id, i ) \

1241 for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((Id) = Gia_ObjId(p, Gia_ManCo(p, i))); i++ )

◆ Gia_ManForEachConst

#define Gia_ManForEachConst	(		p,
			i )

Value:

for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsConst(p, i) ) {} else

Definition at line 1099 of file gia.h.

1099#define Gia_ManForEachConst( p, i ) \

1100 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsConst(p, i) ) {} else

◆ Gia_ManForEachCoReverse

#define Gia_ManForEachCoReverse	(	p,
		pObj,
		i )

Value:

for ( i = Vec_IntSize(p->vCos) - 1; (i >= 0) && ((pObj) = Gia_ManCo(p, i)); i-- )

Definition at line 1242 of file gia.h.

1242#define Gia_ManForEachCoReverse( p, pObj, i ) \

1243 for ( i = Vec_IntSize(p->vCos) - 1; (i >= 0) && ((pObj) = Gia_ManCo(p, i)); i-- )

◆ Gia_ManForEachCoVec

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

Value:

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

Definition at line 1238 of file gia.h.

1238#define Gia_ManForEachCoVec( vVec, p, pObj, i ) \

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

◆ Gia_ManForEachCoWithBoxes

#define Gia_ManForEachCoWithBoxes	(	p,
		pObj,
		i )

Value:

for ( i = p->iFirstPoId; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ManCo(p, i)); i++ )

Definition at line 1267 of file gia.h.

1267#define Gia_ManForEachCoWithBoxes( p, pObj, i ) \

1268 for ( i = p->iFirstPoId; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ManCo(p, i)); i++ )

◆ Gia_ManForEachLut

#define Gia_ManForEachLut	(		p,
			i )

Value:

for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut(p, i) ) {} else

Definition at line 1157 of file gia.h.

1157#define Gia_ManForEachLut( p, i ) \

1158 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut(p, i) ) {} else

◆ Gia_ManForEachLut2

#define Gia_ManForEachLut2	(		p,
			i )

Value:

for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut2(p, i) ) {} else

Definition at line 1168 of file gia.h.

1168#define Gia_ManForEachLut2( p, i ) \

1169 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut2(p, i) ) {} else

◆ Gia_ManForEachLut2Reverse

#define Gia_ManForEachLut2Reverse	(		p,
			i )

Value:

for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsLut2(p, i) ) {} else

Definition at line 1170 of file gia.h.

1170#define Gia_ManForEachLut2Reverse( p, i ) \

1171 for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsLut2(p, i) ) {} else

◆ Gia_ManForEachLut2Vec

#define Gia_ManForEachLut2Vec	(	vIds,
		p,
		vVec,
		iObj,
		i )

Value:

for ( i = 0; i < Vec_IntSize(vIds) && (vVec = Vec_WecEntry(p->vMapping2, (iObj = Vec_IntEntry(vIds, i)))); i++ )

Definition at line 1172 of file gia.h.

1172#define Gia_ManForEachLut2Vec( vIds, p, vVec, iObj, i ) \

1173 for ( i = 0; i < Vec_IntSize(vIds) && (vVec = Vec_WecEntry(p->vMapping2, (iObj = Vec_IntEntry(vIds, i)))); i++ )

◆ Gia_ManForEachLut2VecReverse

#define Gia_ManForEachLut2VecReverse	(	vIds,
		p,
		vVec,
		iObj,
		i )

Value:

for ( i = Vec_IntSize(vIds)-1; i >= 0 && (vVec = Vec_WecEntry(p->vMapping2, (iObj = Vec_IntEntry(vIds, i)))); i-- )

Definition at line 1174 of file gia.h.

1174#define Gia_ManForEachLut2VecReverse( vIds, p, vVec, iObj, i ) \

1175 for ( i = Vec_IntSize(vIds)-1; i >= 0 && (vVec = Vec_WecEntry(p->vMapping2, (iObj = Vec_IntEntry(vIds, i)))); i-- )

◆ Gia_ManForEachLutReverse

#define Gia_ManForEachLutReverse	(		p,
			i )

Value:

for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsLut(p, i) ) {} else

Definition at line 1159 of file gia.h.

1159#define Gia_ManForEachLutReverse( p, i ) \

1160 for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsLut(p, i) ) {} else

◆ Gia_ManForEachMux

#define Gia_ManForEachMux	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else

Definition at line 1226 of file gia.h.

1226#define Gia_ManForEachMux( p, pObj, i ) \

1227 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else

◆ Gia_ManForEachMuxId

#define Gia_ManForEachMuxId	(		p,
			i )

Value:

for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else

Definition at line 1218 of file gia.h.

1218#define Gia_ManForEachMuxId( p, i ) \

1219 for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else

◆ Gia_ManForEachObj

#define Gia_ManForEachObj	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )

MACRO DEFINITIONS ///.

Definition at line 1190 of file gia.h.

1190#define Gia_ManForEachObj( p, pObj, i ) \

1191 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )

◆ Gia_ManForEachObj1

#define Gia_ManForEachObj1	(	p,
		pObj,
		i )

Value:

for ( i = 1; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )

Definition at line 1192 of file gia.h.

1192#define Gia_ManForEachObj1( p, pObj, i ) \

1193 for ( i = 1; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )

◆ Gia_ManForEachObjReverse

#define Gia_ManForEachObjReverse	(	p,
		pObj,
		i )

Value:

for ( i = p->nObjs - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, i)); i-- )

Definition at line 1206 of file gia.h.

1206#define Gia_ManForEachObjReverse( p, pObj, i ) \

1207 for ( i = p->nObjs - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, i)); i-- )

◆ Gia_ManForEachObjReverse1

#define Gia_ManForEachObjReverse1	(	p,
		pObj,
		i )

Value:

for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- )

Definition at line 1208 of file gia.h.

1208#define Gia_ManForEachObjReverse1( p, pObj, i ) \

1209 for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- )

◆ Gia_ManForEachObjReverseWithBoxes

#define Gia_ManForEachObjReverseWithBoxes	(	p,
		pObj,
		i )

Value:

for ( i = p->iFirstPoObj - 1; (i >= p->iFirstAndObj) && ((pObj) = Gia_ManObj(p, i)); i-- )

Definition at line 1263 of file gia.h.

1263#define Gia_ManForEachObjReverseWithBoxes( p, pObj, i ) \

1264 for ( i = p->iFirstPoObj - 1; (i >= p->iFirstAndObj) && ((pObj) = Gia_ManObj(p, i)); i-- )

◆ Gia_ManForEachObjVec

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

Value:

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

Definition at line 1194 of file gia.h.

1194#define Gia_ManForEachObjVec( vVec, p, pObj, i ) \

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

◆ Gia_ManForEachObjVecLit

#define Gia_ManForEachObjVecLit	(	vVec,
		p,
		pObj,
		fCompl,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Abc_Lit2Var(Vec_IntEntry(vVec,i)))) && (((fCompl) = Abc_LitIsCompl(Vec_IntEntry(vVec,i))),1); i++ )

Definition at line 1204 of file gia.h.

1204#define Gia_ManForEachObjVecLit( vVec, p, pObj, fCompl, i ) \

1205 for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Abc_Lit2Var(Vec_IntEntry(vVec,i)))) && (((fCompl) = Abc_LitIsCompl(Vec_IntEntry(vVec,i))),1); i++ )

◆ Gia_ManForEachObjVecReverse

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

Value:

for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i-- )

Definition at line 1202 of file gia.h.

1202#define Gia_ManForEachObjVecReverse( vVec, p, pObj, i ) \

1203 for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i-- )

◆ Gia_ManForEachObjVecStart

#define Gia_ManForEachObjVecStart	(	vVec,
		p,
		pObj,
		i,
		Start )

Value:

for ( i = Start; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )

Definition at line 1196 of file gia.h.

1196#define Gia_ManForEachObjVecStart( vVec, p, pObj, i, Start ) \

1197 for ( i = Start; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )

◆ Gia_ManForEachObjVecStartStop

#define Gia_ManForEachObjVecStartStop	(	vVec,
		p,
		pObj,
		i,
		Start,
		Stop )

Value:

for ( i = Start; (i < Stop) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )

Definition at line 1200 of file gia.h.

1200#define Gia_ManForEachObjVecStartStop( vVec, p, pObj, i, Start, Stop ) \

1201 for ( i = Start; (i < Stop) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )

◆ Gia_ManForEachObjVecStop

#define Gia_ManForEachObjVecStop	(	vVec,
		p,
		pObj,
		i,
		Stop )

Value:

for ( i = 0; (i < Stop) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )

Definition at line 1198 of file gia.h.

1198#define Gia_ManForEachObjVecStop( vVec, p, pObj, i, Stop ) \

1199 for ( i = 0; (i < Stop) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )

◆ Gia_ManForEachObjWithBoxes

#define Gia_ManForEachObjWithBoxes	(	p,
		pObj,
		i )

Value:

for ( i = p->iFirstAndObj; (i < p->iFirstPoObj) && ((pObj) = Gia_ManObj(p, i)); i++ )

Definition at line 1261 of file gia.h.

1261#define Gia_ManForEachObjWithBoxes( p, pObj, i ) \

1262 for ( i = p->iFirstAndObj; (i < p->iFirstPoObj) && ((pObj) = Gia_ManObj(p, i)); i++ )

◆ Gia_ManForEachPi

#define Gia_ManForEachPi	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gia_ManPiNum(p)) && ((pObj) = Gia_ManCi(p, i)); i++ )

Definition at line 1248 of file gia.h.

1248#define Gia_ManForEachPi( p, pObj, i ) \

1249 for ( i = 0; (i < Gia_ManPiNum(p)) && ((pObj) = Gia_ManCi(p, i)); i++ )

◆ Gia_ManForEachPo

#define Gia_ManForEachPo	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gia_ManPoNum(p)) && ((pObj) = Gia_ManCo(p, i)); i++ )

Definition at line 1250 of file gia.h.

1250#define Gia_ManForEachPo( p, pObj, i ) \

1251 for ( i = 0; (i < Gia_ManPoNum(p)) && ((pObj) = Gia_ManCo(p, i)); i++ )

◆ Gia_ManForEachRi

#define Gia_ManForEachRi	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCo(p, Gia_ManPoNum(p)+i)); i++ )

Definition at line 1254 of file gia.h.

1254#define Gia_ManForEachRi( p, pObj, i ) \

1255 for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCo(p, Gia_ManPoNum(p)+i)); i++ )

◆ Gia_ManForEachRiRo

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

Value:

for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObjRi) = Gia_ManCo(p, Gia_ManPoNum(p)+i)) && ((pObjRo) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )

Definition at line 1256 of file gia.h.

1256#define Gia_ManForEachRiRo( p, pObjRi, pObjRo, i ) \

1257 for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObjRi) = Gia_ManCo(p, Gia_ManPoNum(p)+i)) && ((pObjRo) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )

◆ Gia_ManForEachRo

#define Gia_ManForEachRo	(	p,
		pObj,
		i )

Value:

for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )

Definition at line 1252 of file gia.h.

1252#define Gia_ManForEachRo( p, pObj, i ) \

1253 for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )

◆ Gia_ManForEachRoToRiVec

#define Gia_ManForEachRoToRiVec	(	vRoIds,
		p,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_IntSize(vRoIds)) && ((pObj) = Gia_ObjRoToRi(p, Gia_ManObj(p, Vec_IntEntry(vRoIds, i)))); i++ )

Definition at line 1258 of file gia.h.

1258#define Gia_ManForEachRoToRiVec( vRoIds, p, pObj, i ) \

1259 for ( i = 0; (i < Vec_IntSize(vRoIds)) && ((pObj) = Gia_ObjRoToRi(p, Gia_ManObj(p, Vec_IntEntry(vRoIds, i)))); i++ )

◆ GIA_NONE

#define GIA_NONE 0x1FFFFFFF

INCLUDES ///.

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

FileName [gia.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

] PARAMETERS ///

Definition at line 45 of file gia.h.

◆ Gia_ObjForEachFanoutStatic

#define Gia_ObjForEachFanoutStatic	(	p,
		pObj,
		pFanout,
		i )

Value:

for ( i = 0; (i < Gia_ObjFanoutNum(p, pObj)) && (((pFanout) = Gia_ObjFanout(p, pObj, i)), 1); i++ )

Definition at line 1125 of file gia.h.

1125#define Gia_ObjForEachFanoutStatic( p, pObj, pFanout, i ) \

1126 for ( i = 0; (i < Gia_ObjFanoutNum(p, pObj)) && (((pFanout) = Gia_ObjFanout(p, pObj, i)), 1); i++ )

◆ Gia_ObjForEachFanoutStaticId

#define Gia_ObjForEachFanoutStaticId	(	p,
		Id,
		FanId,
		i )

Value:

for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && ((FanId = Gia_ObjFanoutId(p, Id, i)), 1); i++ )

Definition at line 1127 of file gia.h.

1127#define Gia_ObjForEachFanoutStaticId( p, Id, FanId, i ) \

1128 for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && ((FanId = Gia_ObjFanoutId(p, Id, i)), 1); i++ )

◆ Gia_ObjForEachFanoutStaticIndex

#define Gia_ObjForEachFanoutStaticIndex	(	p,
		Id,
		FanId,
		i,
		Index )

Value:

for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && (Index = Vec_IntEntry(p->vFanout, Id)+i) && ((FanId = Vec_IntEntry(p->vFanout, Index)), 1); i++ )

Definition at line 1129 of file gia.h.

1129#define Gia_ObjForEachFanoutStaticIndex( p, Id, FanId, i, Index ) \

1130 for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && (Index = Vec_IntEntry(p->vFanout, Id)+i) && ((FanId = Vec_IntEntry(p->vFanout, Index)), 1); i++ )

◆ GIA_ONE

#define GIA_ONE 2

Definition at line 922 of file gia.h.

◆ GIA_UND

#define GIA_UND 3

Definition at line 923 of file gia.h.

◆ GIA_VOID

#define GIA_VOID 0x0FFFFFFF

Definition at line 46 of file gia.h.

◆ GIA_ZER

#define GIA_ZER 1

Definition at line 921 of file gia.h.

Typedef Documentation

◆ Bnd_Man_t

typedef struct Bnd_Man_t_ Bnd_Man_t

Definition at line 1830 of file gia.h.

◆ Cbs_Man_t

typedef struct Cbs_Man_t_ Cbs_Man_t

Definition at line 1305 of file gia.h.

◆ Emb_Par_t

typedef struct Emb_Par_t_ Emb_Par_t

Definition at line 277 of file gia.h.

◆ Gia_ChMan_t

typedef struct Gia_ChMan_t_ Gia_ChMan_t

Definition at line 1416 of file gia.h.

◆ Gia_Dat_t

typedef struct Gia_Dat_t_ Gia_Dat_t

Definition at line 55 of file gia.h.

◆ Gia_Man2Min_t

typedef struct Gia_Man2Min_t_ Gia_Man2Min_t

Definition at line 1669 of file gia.h.

◆ Gia_Man_t

typedef struct Gia_Man_t_ Gia_Man_t

Definition at line 96 of file gia.h.

◆ Gia_ManMin_t

typedef struct Gia_ManMin_t_ Gia_ManMin_t

Definition at line 1665 of file gia.h.

◆ Gia_ManSim_t

typedef struct Gia_ManSim_t_ Gia_ManSim_t

Definition at line 319 of file gia.h.

◆ Gia_MmFixed_t

typedef struct Gia_MmFixed_t_ Gia_MmFixed_t

BASIC TYPES ///.

Definition at line 52 of file gia.h.

◆ Gia_MmFlex_t

typedef struct Gia_MmFlex_t_ Gia_MmFlex_t

Definition at line 53 of file gia.h.

◆ Gia_MmStep_t

typedef struct Gia_MmStep_t_ Gia_MmStep_t

Definition at line 54 of file gia.h.

◆ Gia_Obj_t

typedef struct Gia_Obj_t_ Gia_Obj_t

Definition at line 76 of file gia.h.

◆ Gia_ParFra_t

typedef struct Gia_ParFra_t_ Gia_ParFra_t

Definition at line 293 of file gia.h.

◆ Gia_ParSim_t

typedef struct Gia_ParSim_t_ Gia_ParSim_t

Definition at line 306 of file gia.h.

◆ Gia_Plc_t

typedef struct Gia_Plc_t_ Gia_Plc_t

Definition at line 67 of file gia.h.

◆ Gia_Rpr_t

typedef struct Gia_Rpr_t_ Gia_Rpr_t

Definition at line 57 of file gia.h.

◆ Gps_Par_t

typedef struct Gps_Par_t_ Gps_Par_t

Definition at line 260 of file gia.h.

◆ Jf_Par_t

typedef struct Jf_Par_t_ Jf_Par_t

Definition at line 333 of file gia.h.

◆ Tas_Man_t

typedef struct Tas_Man_t_ Tas_Man_t

Definition at line 1821 of file gia.h.

Function Documentation

◆ Bnd_ManCheckBound()

int Bnd_ManCheckBound	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description [check if the given boundary is valid. Return 0 if the boundary is invalid. Return k if the boundary is valid and there're k boundary inputs. Can be called even if Bnd_Man_t is not created]

SideEffects []

SeeAlso []

Definition at line 379 of file giaBound.c.

{
    int i;
    Gia_Obj_t *pObj;
    int valid = 1;
    int nBI = 0, nBO = 0, nInternal = 0;
 
    if ( fVerbose ) printf( "Checking boundary... \n");
 
    Vec_Int_t *vPath;
    vPath = Vec_IntAlloc( Gia_ManObjNum(p) );
    Vec_IntFill( vPath, Gia_ManObjNum(p), 0 );
    int path;
 
    Gia_ManForEachObjReverse1( p , pObj, i )
    {
        if ( Gia_ObjIsCo( pObj ) )
        {
            Vec_IntSetEntry( vPath, Gia_ObjId( p, pObj ), 1 );
        }
 
        path = Vec_IntEntry( vPath, Gia_ObjId(p, pObj) );
        // printf("path = %d\n", path);
 
        if ( path >= 8 )
        {
            valid = 0;
            printf("there're more than 2 bufs in a path\n");
            break;
        }
 
 
        if( Gia_ObjIsBuf( pObj ) )
        {
            Vec_IntSetEntry( vPath, Gia_ObjId( p, Gia_ObjFanin0( pObj ) ), Vec_IntEntry( vPath, Gia_ObjId(p, Gia_ObjFanin0( pObj ) ) ) | path << 1 );
            if ( path == 1 )  // boundary input
            {
                // TODO: record BIs here since they may not be in the first n buffers
                nBO ++;
            }
        }
        else if ( Gia_ObjFaninNum( p, pObj ) >= 1 )
        {
            Vec_IntSetEntry( vPath, Gia_ObjId( p, Gia_ObjFanin0( pObj ) ), Vec_IntEntry( vPath, Gia_ObjId(p, Gia_ObjFanin0( pObj ) ) ) | path );
            if ( Gia_ObjFaninNum( p, pObj ) >= 2 )
            {
                assert( Gia_ObjFaninNum( p, pObj ) <= 2  );
                Vec_IntSetEntry( vPath, Gia_ObjId( p, Gia_ObjFanin1( pObj ) ), Vec_IntEntry( vPath, Gia_ObjId(p, Gia_ObjFanin1( pObj ) ) ) | path );
            }
            if ( path == 2 )  // inside boundary
            {
                // TODO: record BIs here since they may not be in the first n buffers
                nInternal ++;
            }
        }
        else // PI or const, check validity
        {
            if ( (Vec_IntEntry( vPath, Gia_ObjId(p, pObj) ) | 5) != 5 )
            {
                valid = 0;
                printf("incorrect buf number at pi %d\n", Vec_IntEntry(vPath, Gia_ObjId(p, pObj)) );
                break;
            }
        }
    }
 
    nBI = Gia_ManBufNum(p) - nBO;
 
    if ( !valid ) 
    {
        printf("invalid boundary\n");
        return 0;
    }
    else if ( nBI == 0 )
    {
        printf("no boundary\n");
        return 0;
    }
    else 
    {
        if ( fVerbose )
        {
            printf("valid boundary (");
            printf("#BI = %d\t#BO = %d\t", nBI, Gia_ManBufNum(p)- nBI);
            printf("#Internal = %d)\n", nInternal );
        }
        if ( pBnd )
        {
            pBnd -> nBI = nBI;
            pBnd -> nBO = nBO;
            pBnd -> nInternal = nInternal;
        }
        return nBI;
    }
}

Here is the caller graph for this function:

◆ Bnd_ManCheckCoMerged()

int Bnd_ManCheckCoMerged ( Gia_Man_t * p )

extern

Definition at line 1352 of file giaBound.c.

{
    int nCO = Gia_ManCoNum(p)/2;
    
    Gia_Obj_t* pObj1;
    Gia_Obj_t* pObj2;
 
    for ( int i = 0; i < nCO; i++ )
    {
        pObj1 = Gia_ManCo(p, i);
        pObj2 = Gia_ManCo(p, i + nCO);
        if ( Gia_ObjFaninLit0p(p, pObj1) != Gia_ObjFaninLit0p(p, pObj2) ) return 0;
    }
    return 1;
}

◆ Bnd_ManCutBoundary()

Gia_Man_t * Bnd_ManCutBoundary	(	Gia_Man_t *	p,
		Vec_Int_t *	vEI,
		Vec_Int_t *	vEO,
		Vec_Bit_t *	vEI_phase,
		Vec_Bit_t *	vEO_phase )

extern

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

Synopsis []

Description [create circuit with the boundary changed to CI/CO]

SideEffects []

SeeAlso []

Definition at line 780 of file giaBound.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    Vec_Int_t * vValue;
    int i, id, lit;
 
    // check if the boundary has loop (EO cannot be in the TFC of EI )
    if ( !Bnd_ManCheckExtBound( p, vEI, vEO ) )
    {
        printf("Combinational loop exist\n");
        pBnd -> combLoop_impl = 1;
        return 0;
    }
 
    // initialize
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew -> pName = ABC_ALLOC( char, strlen(p->pName)+10);
    sprintf( pNew -> pName, "%s_out", p -> pName );
    Gia_ManHashStart( pNew );
    Gia_ManFillValue(p);
    Gia_ManConst0(p) -> Value = 0;
 
 
    // record the original value for eo
    vValue = Vec_IntAlloc( Gia_ManObjNum(p) );
    Vec_IntFill( vValue, Gia_ManObjNum(p), -1 );
 
    // create ci for ci and eo
    Gia_ManForEachCi( p, pObj, i )
    {
        pObj -> Value = Gia_ManAppendCi( pNew );
    }
    Vec_IntForEachEntry( vEO, id, i )
    {
        if( Gia_ManObj(p, id) -> Value != ~0 )
        {
            Vec_IntSetEntry( vValue, id, Gia_ManObj(p, id) -> Value );
        }
        Gia_ManObj( p, id ) -> Value = Gia_ManAppendCi(pNew);
        if ( vEO_phase && Vec_BitEntry( vEO_phase, i ) )
        {
            Gia_ManObj( p, id ) -> Value ^= 1;
        }
    }
 
    // add aig nodes
    Gia_ManForEachAnd(p, pObj, i)
    {
        if ( pObj -> Value != ~0 ) continue;
        pObj -> Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    }
 
    // create co for co and ei
    Gia_ManForEachCo(p, pObj, i)
    {
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Vec_IntForEachEntry( vEI, id, i )
    {
        pObj = Gia_ManObj(p, id);
        // lit = Gia_ManObj(p, id)->Value;
        if ( Gia_ObjIsAnd(pObj) ) lit = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else 
        {
            assert(Gia_ObjIsCi(pObj) || Gia_ObjIsConst0(pObj));
            if ( Vec_IntEntry(vValue, id) != -1 )
            {
                lit = Vec_IntEntry( vValue, id );   // EI at PI and EI merged with EO
            }
            else { 
                lit = pObj -> Value;    // EI at PI
            }
        }
        if ( vEI_phase && Vec_BitEntry( vEI_phase, i ) ) lit ^= 1;
        Gia_ManAppendCo( pNew, lit );
    }
 
    // clean up
    Vec_IntFree( vValue );
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bnd_ManFinalizeMappings()

void Bnd_ManFinalizeMappings ( )

extern

Definition at line 232 of file giaBound.c.

{
 
    Vec_Ptr_t* vBmiter2Spec = pBnd -> vBmiter2Spec;
    Vec_Ptr_t* vBmiter2Impl = pBnd -> vBmiter2Impl;
 
    Vec_Int_t *vSpec, *vImpl;
    int i, j, id;
 
    pBnd -> nMerged_impl = 0;
    pBnd -> nMerged_spec = 0;
 
 
    for( i = 0; i < Vec_PtrSize(vBmiter2Spec); i++ )
    {
        vSpec = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Spec, i );
        vImpl = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Impl, i );
 
        Vec_IntForEachEntry( vSpec, id, j )
        {
            // vSpec2Bmiter
            Vec_IntSetEntry( pBnd->vSpec2Bmiter, id, i );
        }
 
        Vec_IntForEachEntry( vImpl, id, j )
        {
            // vImpl2Bmiter
            Vec_IntSetEntry( pBnd->vImpl2Bmiter, id, i );
        }
 
        // count number of nodes merged into the same circuit
        if ( Vec_IntSize(vSpec) != 0 )
        {
            pBnd->nMerged_spec += Vec_IntSize(vSpec) - 1;
        }
        if ( Vec_IntSize(vImpl) != 0 )
        {
            pBnd->nMerged_impl += Vec_IntSize(vImpl) - 1;
        }
    }
 
}

Here is the caller graph for this function:

◆ Bnd_ManFindBound()

void Bnd_ManFindBound	(	Gia_Man_t *	p,
		Gia_Man_t *	pImpl )

extern

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

Synopsis []

Description [find the extended boundary in spec and compute the corresponding boundary in impl]

SideEffects []

SeeAlso []

Definition at line 549 of file giaBound.c.

{
    Vec_Int_t  *vFlag;
    Vec_Ptr_t *vQ;
    Gia_Obj_t *pObj;
    int i, j, id, cnt;
 
    Vec_Int_t *vAI = Vec_IntAlloc(16);
    Vec_Int_t *vAO = Vec_IntAlloc(16);
 
    Vec_Bit_t *vSpec2Impl_phase = pBnd -> vSpec2Impl_phase;
    Vec_Int_t *vBI = pBnd -> vBI;
    Vec_Int_t *vBO = pBnd -> vBO;
    Vec_Int_t *vEI_spec = pBnd -> vEI_spec;
    Vec_Int_t *vEO_spec = pBnd -> vEO_spec;
    Vec_Int_t *vEI_impl = pBnd -> vEI_impl;
    Vec_Int_t *vEO_impl = pBnd -> vEO_impl;
    Vec_Bit_t *vEI_phase = pBnd -> vEI_phase;
    Vec_Bit_t *vEO_phase = pBnd -> vEO_phase;
 
 
    // prepare to compute extended boundary
    vQ = Vec_PtrAlloc(16);
    vFlag = Vec_IntAlloc( Gia_ManObjNum(p) );
    Vec_IntFill( vFlag, Gia_ManObjNum(p), 0 );
 
    Gia_ManStaticFanoutStart(p);
 
    // save bo, bi
    cnt = 0;
    Gia_ManForEachBuf(p, pObj, i)
    {
        if ( cnt < pBnd -> nBI ) 
        {
            Vec_IntPush( vBI, Gia_ObjId(p, Gia_ObjFanin0(pObj) ) );
        }
        else 
        {
            Vec_IntPush( vBO, Gia_ObjId(p, pObj) );
        }
        cnt++;
    }
 
    // compute EO, travse with flag 1
    Vec_IntForEachEntry( vBO, id, i )
    {
        if ( Bnd_ManSpec2ImplNum(id) == 0 ) // BO not matched 
        {
            Vec_PtrPush( vQ, Gia_ManObj(p, id) );
        }
        else
        {
            Vec_IntPush(vEO_spec, id);
        }
    }
    if ( pBnd -> fVerbose )  printf("%d BO doesn't match. ", Vec_PtrSize(vQ) );
    pBnd -> nBO_miss = Vec_PtrSize(vQ);
 
    int cnt_extra = - Vec_PtrSize(vQ);
    while( Vec_PtrSize(vQ) > 0 )
    {
        pObj = (Gia_Obj_t *)Vec_PtrPop(vQ);
        id = Gia_ObjId( p, pObj );
 
        if ( Vec_IntEntry( vFlag, id  ) == 1 ) continue;
        Vec_IntSetEntry( vFlag, id, 1 );
 
        // printf("%d\n", id);
 
        if ( Bnd_ManSpec2ImplNum(id) != 0 )    // matched
        {
            Vec_IntPush( vEO_spec, id );
            Vec_IntPush( vAO, id );
        }
        else
        {
            for( j = 0; j < Gia_ObjFanoutNum(p, pObj); j++ )
            {
                Vec_PtrPush( vQ, Gia_ObjFanout(p, pObj, j) );
                // printf("\t%d\n", Gia_ObjId( p1, Gia_ObjFanout(p1, pObj, j) ) );
            }
        }
    }
    // printf("%d AO found with %d extra nodes\n", Vec_IntSize(vAO) , cnt_extra );
    if ( pBnd -> fVerbose ) printf("%d AO found\n", Vec_IntSize(vAO) );
 
 
    // mark TFOC of BO with flag 1 to prevent them from being selected into EI
    // stop at CO
    Vec_IntForEachEntry( pBnd -> vBO, id, i )
    {
        Vec_PtrPush( vQ, Gia_ManObj(p, id) );
    }
    Vec_IntForEachEntry( vFlag, id, i )
    {
        Vec_IntSetEntry( vFlag, id, 0 );
    }
    while( Vec_PtrSize(vQ) > 0 )
    {
        pObj = (Gia_Obj_t *)Vec_PtrPop(vQ);
        id = Gia_ObjId( p, pObj );
 
        if ( Vec_IntEntry( vFlag, id  ) == 1 ) continue;
        Vec_IntSetEntry( vFlag, id, 1 );
 
        for( j = 0; j < Gia_ObjFanoutNum(p, pObj); j++ )
        {
            Vec_PtrPush( vQ, Gia_ObjFanout(p, pObj, j) );
        }
    }
 
 
 
    // compute EI,  traverse with flag 2
 
    // add unmatched BI to queue
    Vec_IntForEachEntry( vBI, id, i )
    {
        if ( Bnd_ManSpec2ImplNum(id) == 0 ) // BO not matched 
        {
            Vec_PtrPush( vQ, Gia_ManObj(p, id) );
        }
        else
        {
            Vec_IntPush(vEI_spec, id);
        }
    }
    if ( pBnd -> fVerbose ) printf("%d BI doesn't match. ", Vec_PtrSize(vQ) );
    pBnd -> nBI_miss = Vec_PtrSize(vQ);
    cnt_extra -= Vec_PtrSize(vQ);
 
    // add AO to queue
    Vec_IntForEachEntry( vAO, id, i )
    {
        Vec_PtrPush( vQ, Gia_ManObj(p, id) );
    }
 
    // set flag 2 for BO
    Vec_IntForEachEntry( vBO, id, i )
    {
        Vec_IntSetEntry( vFlag, id, 2 );
    }
 
    // traverse down from AI and unmatched BI
    while( Vec_PtrSize(vQ) > 0 )
    {
        pObj = (Gia_Obj_t *)Vec_PtrPop(vQ);
        id = Gia_ObjId( p, pObj );
 
        if ( Vec_IntEntry( vFlag, id  ) == 2 ) continue;
        cnt_extra ++;
 
        // printf("%d\n", id);
 
        if ( Vec_IntEntry(vFlag, id) != 1 && Bnd_ManSpec2ImplNum(id) != 0 )    // matched
        {
            Vec_IntPush( vEI_spec, id );
            Vec_IntPush( vAI, id );
        }
        else
        {
            for( j = 0; j < Gia_ObjFaninNum(p, pObj); j++ )
            {
                Vec_PtrPush( vQ, Gia_ObjFanin(pObj, j) );
                // printf("\t%d\n", Gia_ObjId( p1, Gia_ObjFanout(p1, pObj, j) ) );
            }
        }
 
        Vec_IntSetEntry( vFlag, id, 2 );
    }
    if ( pBnd -> fVerbose ) printf("%d AI found with %d extra nodes in total\n", Vec_IntSize(vAI) , cnt_extra );
    pBnd -> nExtra = cnt_extra;
 
 
    // gen vEI_impl, vEO_impl, vEI_phase, vEO_phase
    Vec_IntForEachEntry( vEI_spec, id, i )
    {
        Vec_IntPush( vEI_impl, Vec_IntEntry( Bnd_ManSpec2Impl(id) , 0 ) );
        Vec_BitPush( vEI_phase, Vec_BitEntry( vSpec2Impl_phase, id ) );
    }
    Vec_IntForEachEntry( vEO_spec, id, i )
    {
        Vec_IntPush( vEO_impl, Vec_IntEntry( Bnd_ManSpec2Impl(id), 0 ) );
        Vec_BitPush( vEO_phase, Vec_BitEntry( vSpec2Impl_phase, id ) );
    }
 
 
    // count number of choice of boundary
    Vec_IntForEachEntry( vEO_spec, id, i )
    {
        pBnd -> nChoice_impl += Bnd_ManSpec2ImplNum( id ) - 1;
    }
    Vec_IntForEachEntry( vEO_impl, id, i )
    {
        pBnd -> nChoice_spec += Bnd_ManImpl2SpecNum( id ) - 1;
    }
 
    // print
    if ( pBnd -> fVerbose )
    {
        printf("#EI = %d\t#EO = %d\t#Extra Node = %d\n", Vec_IntSize(vEI_spec) , Vec_IntSize(vEO_spec), cnt_extra );
        Bnd_ManPrintBound();
    }
 
    // check boundary has comb loop
    if ( !Bnd_ManCheckExtBound( p, vEI_spec, vEO_spec ) )
    {
 
        printf("Combinational loop exist\n");
        pBnd -> combLoop_spec = 1;
 
    }
 
 
    // clean up
    Vec_IntFree(vAI);
    Vec_IntFree(vAO);
}

Here is the call graph for this function:

◆ Bnd_ManGenImplOut()

Gia_Man_t * Bnd_ManGenImplOut ( Gia_Man_t * p )

extern

Definition at line 873 of file giaBound.c.

{
    if ( pBnd -> fVerbose ) printf("Generating impl_out with given boundary.\n");
    Gia_Man_t *pNew = Bnd_ManCutBoundary( p, pBnd->vEI_impl, pBnd->vEO_impl, pBnd->vEI_phase, pBnd->vEO_phase );
    if (!pNew) pBnd -> combLoop_impl = 1;
    return pNew;
}

Here is the call graph for this function:

◆ Bnd_ManGenPatched()

Gia_Man_t * Bnd_ManGenPatched	(	Gia_Man_t *	pOut,
		Gia_Man_t *	pSpec,
		Gia_Man_t *	pPatch )

extern

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

Synopsis []

Description [perform ECO directly (not used)]

SideEffects []

SeeAlso []

Definition at line 922 of file giaBound.c.

{
 
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, id, cnt;
    Vec_Int_t *vBI_patch, *vBO_patch;
 
    pBnd -> nNode_patch = Gia_ManAndNotBufNum( pPatch );
 
    pNew = Gia_ManStart( Gia_ManObjNum(pOut) + Gia_ManObjNum( pSpec ) + Gia_ManObjNum(pPatch) );
    pNew -> pName = ABC_ALLOC( char, strlen(pOut->pName)+3);
    sprintf( pNew -> pName, "%s_p", pOut -> pName );
    Gia_ManHashStart( pNew );
    Gia_ManFillValue(pOut);
    Gia_ManFillValue(pSpec);
    Gia_ManFillValue(pPatch);
    Gia_ManConst0(pOut)->Value = 0;
    Gia_ManConst0(pSpec)->Value = 0;
    Gia_ManConst0(pPatch)->Value = 0;
 
    // get bi and bo in patch
    cnt = 0;
    vBI_patch = Vec_IntAlloc(16);
    vBO_patch = Vec_IntAlloc(16);
    Gia_ManForEachBuf( pPatch, pObj, i )
    {
        if ( cnt < pBnd -> nBI )
        {
            Vec_IntPush( vBI_patch, Gia_ObjId( pPatch, pObj ) );
        }
        else
        {
 
            Vec_IntPush( vBO_patch, Gia_ObjId( pPatch, pObj ) );
        }
        cnt ++;
    }
    assert( Vec_IntSize( vBI_patch ) == Vec_IntSize(pBnd->vBI) );
    assert( Vec_IntSize( vBO_patch ) == Vec_IntSize(pBnd->vBO) );
 
 
    // add Impl (real) PI
    for ( i = 0; i < Gia_ManCiNum(pSpec); i++ )
    {
        pObj = Gia_ManCi(pOut, i);
        pObj -> Value = Gia_ManAppendCi( pNew );
    }
 
    // add Impl EI to CI
    // printf("adding EI to CI in Impl\n");
    for ( i = 0; i < Vec_IntSize( pBnd -> vEI_spec ); i++ )
    {
        pObj = Gia_ManCo(pOut, i + Gia_ManCoNum(pSpec) );
        Bnd_AddNodeRec( pOut, pNew, pObj, 0 );
 
        // set Spec EI
        Gia_ManObj( pSpec, Vec_IntEntry(pBnd -> vEI_spec, i) ) -> Value = pObj -> Value;
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
    // add Spec BI to EI
    // printf("adding BI to EI in Spec\n");
    Vec_IntForEachEntry( pBnd -> vBI, id, i )
    {
        pObj = Gia_ManObj( pSpec, id );
        Bnd_AddNodeRec( pSpec, pNew, pObj, 0 );
 
        // set patch bi
        Gia_ManObj( pPatch, Vec_IntEntry( vBI_patch, i) ) -> Value = pObj -> Value;
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
    // add Patch BO to BI
    // printf("adding BO to BI in Patch\n");
    Vec_IntForEachEntry( vBO_patch, id, i )
    {
        pObj = Gia_ManObj( pPatch, id );
        Bnd_AddNodeRec( pPatch, pNew, pObj, 0 );
 
        // set spec bo
        Gia_ManObj( pSpec, Vec_IntEntry( pBnd -> vBO, i) ) -> Value = pObj -> Value;
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
    // add Spec EO to BO
    // printf("adding EO to BO in Spec\n");
    Vec_IntForEachEntry( pBnd -> vEO_spec, id, i )
    {
        pObj = Gia_ManObj( pSpec, id );
        Bnd_AddNodeRec( pSpec, pNew, pObj, 0 );
 
        // set impl EO (PI)
        Gia_ManCi( pOut, i + Gia_ManCiNum(pSpec) ) -> Value = pObj -> Value;
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
    // add Impl (real) PO to EO
    // printf("adding CO to EO in Impl\n");
    for ( i = 0; i < Gia_ManCoNum(pSpec); i++ )
    {
        pObj = Gia_ManCo( pOut, i );
        Bnd_AddNodeRec( pOut, pNew, pObj, 0 );
        Gia_ManAppendCo( pNew, pObj->Value );
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
 
    // clean up
    Vec_IntFree( vBI_patch );
    Vec_IntFree( vBO_patch );
    Gia_ManHashStop( pNew );
 
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
 
    pBnd -> nNode_patched = Gia_ManAndNum( pNew );
 
    return pNew;
}

Here is the call graph for this function:

◆ Bnd_ManGenPatched1()

Gia_Man_t * Bnd_ManGenPatched1	(	Gia_Man_t *	pOut,
		Gia_Man_t *	pSpec )

extern

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

Synopsis []

Description [recover bounadry]

SideEffects []

SeeAlso []

Definition at line 1059 of file giaBound.c.

{
 
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, id;
 
    pNew = Gia_ManStart( Gia_ManObjNum(pOut) + Gia_ManObjNum( pSpec ) );
    pNew -> pName = ABC_ALLOC( char, strlen(pOut->pName)+3);
    sprintf( pNew -> pName, "%s_p", pOut -> pName );
 
    Gia_ManFillValue(pOut);
    Gia_ManFillValue(pSpec);
    Gia_ManConst0(pOut)->Value = 0;
    Gia_ManConst0(pSpec)->Value = 0;
 
 
    // add Impl (real) PI
    for ( i = 0; i < Gia_ManCiNum(pSpec); i++ )
    {
        pObj = Gia_ManCi(pOut, i);
        pObj -> Value = Gia_ManAppendCi( pNew );
    }
 
    // add Impl EI to CI
    // printf("adding EI to CI in Impl\n");
    for ( i = 0; i < Vec_IntSize( pBnd -> vEI_spec ); i++ )
    {
        pObj = Gia_ManCo(pOut, i + Gia_ManCoNum(pSpec) );
        Bnd_AddNodeRec( pOut, pNew, pObj, 1 );
 
        // set Spec EI
        Gia_ManObj( pSpec, Vec_IntEntry(pBnd -> vEI_spec, i) ) -> Value = pObj -> Value;
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
    // add Spec EO to EI
    // add BI -> BO -> EO to maintain the order of bufs
    // Vec_IntForEachEntry( pBnd -> vBI, id, i )
    // {
    //     pObj = Gia_ManObj( pSpec, id );
    //     Bnd_AddNodeRec( pSpec, pNew, pObj, 1 );
    // }
    // Vec_IntForEachEntry( pBnd -> vBO, id, i )
    // {
    //     pObj = Gia_ManObj( pSpec, id );
    //     Bnd_AddNodeRec( pSpec, pNew, pObj, 1 );
    // }
    Gia_ManForEachBuf( pSpec, pObj, i )
    {
        Bnd_AddNodeRec( pSpec, pNew, pObj, 1 );
    }
    Vec_IntForEachEntry( pBnd -> vEO_spec, id, i )
    {
        pObj = Gia_ManObj( pSpec, id );
        Bnd_AddNodeRec( pSpec, pNew, pObj, 1 );
 
        // set impl EO (PI)
        Gia_ManCi( pOut, i + Gia_ManCiNum(pSpec) ) -> Value = pObj -> Value;
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
    // add Impl (real) PO to EO
    // printf("adding CO to EO in Impl\n");
    for ( i = 0; i < Gia_ManCoNum(pSpec); i++ )
    {
        pObj = Gia_ManCo( pOut, i );
        Bnd_AddNodeRec( pOut, pNew, pObj, 1 );
        Gia_ManAppendCo( pNew, pObj->Value );
        // printf(" %d",pObj -> Value);
    }
    // printf("\n");
 
 
    // clean up
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
 
    pBnd -> nNode_patched = Gia_ManAndNum( pNew );
 
    return pNew;
}

Here is the call graph for this function:

◆ Bnd_ManGenPatched2()

Gia_Man_t * Bnd_ManGenPatched2	(	Gia_Man_t *	pImpl,
		Gia_Man_t *	pPatch,
		int	fSkipStrash,
		int	fVerbose )

extern

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

Synopsis []

Description [perform eco with recovered boundary. bnd_man is not used]

SideEffects []

SeeAlso []

Definition at line 1156 of file giaBound.c.

{
 
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, nBI, nBI_patch, cnt;
    Vec_Int_t* vLit;
 
 
    // check boundary first
    nBI = Bnd_ManCheckBound( pImpl, fVerbose );
    nBI_patch = Bnd_ManCheckBound( pPatch, fVerbose );
    if ( 0 == nBI_patch || Gia_ManBufNum(pImpl) != Gia_ManBufNum(pPatch) || nBI != nBI_patch )
    {
        Abc_Print( -1, "Abc_CommandAbc9StrEco(): The given boundary is invalid.\n" );
        return 0; 
    }
 
    // prepare new network
    pNew = Gia_ManStart( Gia_ManObjNum(pImpl) + Gia_ManObjNum( pPatch ) );
    pNew -> pName = ABC_ALLOC( char, strlen(pImpl->pName)+3);
    sprintf( pNew -> pName, "%s_p", pImpl -> pName );
    if ( !fSkipStrash )
    {
        Gia_ManHashAlloc( pNew );
    }
    Gia_ManFillValue(pImpl);
    Gia_ManFillValue(pPatch);
    Gia_ManConst0(pImpl)->Value = 0;
    Gia_ManConst0(pPatch)->Value = 0;
 
    vLit = Vec_IntAlloc( Gia_ManBufNum(pImpl) );
 
    // add Impl (real) CI
    Gia_ManForEachCi( pImpl, pObj, i )
    {
        pObj -> Value = Gia_ManAppendCi( pNew );
    }
 
    // add Impl BI to CI
    cnt = 0;
    Gia_ManForEachBuf( pImpl, pObj, i )
    {
        Bnd_AddNodeRec( pImpl, pNew, pObj, fSkipStrash );
        Vec_IntPush( vLit, pObj -> Value );
        cnt ++;
        if ( cnt >= nBI ) break;
    }
    
    // set BI in patch
    // add patch BO to BI
    cnt = 0;
    Gia_ManForEachBuf( pPatch, pObj, i )
    {
        if ( cnt < nBI ) 
        {
            pObj -> Value = Vec_IntEntry( vLit, cnt );
        }
        else
        {
            Bnd_AddNodeRec( pPatch, pNew, pObj, fSkipStrash );
            Vec_IntPush( vLit, pObj -> Value );
        }
        cnt ++;
        if ( cnt == nBI ) Vec_IntClear( vLit );
    }
 
    // set BO in impl
    cnt = 0;
    Gia_ManForEachBuf( pImpl, pObj, i )
    {
        cnt ++;
        if ( cnt <= nBI) continue;
        pObj -> Value = Vec_IntEntry( vLit, cnt-nBI-1 );
    }
 
    // add impl CO to BO
    Gia_ManForEachCo( pImpl, pObj, i )
    {
        Bnd_AddNodeRec( pImpl, pNew, pObj, fSkipStrash );
        Gia_ManAppendCo( pNew, pObj -> Value );
    }
 
    // clean up
    if ( !fSkipStrash ) 
    {
        Gia_ManHashStop( pNew );
    }
    Vec_IntFree( vLit );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
 
    return pNew;
}

Here is the call graph for this function:

◆ Bnd_ManGenSpecOut()

Gia_Man_t * Bnd_ManGenSpecOut ( Gia_Man_t * p )

extern

Definition at line 867 of file giaBound.c.

{
    if ( pBnd -> fVerbose ) printf("Generating spec_out with given boundary.\n");
    Gia_Man_t *pNew = Bnd_ManCutBoundary( p, pBnd->vEI_spec, pBnd->vEO_spec, 0, 0 );
    return pNew;
}

Here is the call graph for this function:

◆ Bnd_ManGetNExtra()

int Bnd_ManGetNExtra ( )

extern

Definition at line 176 of file giaBound.c.

176{ assert(pBnd); return pBnd -> nExtra; }

◆ Bnd_ManGetNInternal()

int Bnd_ManGetNInternal ( )

extern

Definition at line 175 of file giaBound.c.

175{ assert(pBnd); return pBnd -> nInternal; }

◆ Bnd_ManMap()

void Bnd_ManMap	(	int	iLit,
		int	id,
		int	spec )

extern

Definition at line 178 of file giaBound.c.

{
 
    if ( spec )
    {
        Vec_IntPush( (Vec_Int_t *)Vec_PtrEntry( pBnd -> vBmiter2Spec, iLit >> 1), id ); 
        Vec_BitSetEntry( pBnd -> vSpec2Impl_phase, id, iLit & 1 );
    }
    else 
    {
        assert( (iLit & 1) == 0 );
        Vec_IntPush( (Vec_Int_t *)Vec_PtrEntry( pBnd -> vBmiter2Impl, iLit >> 1), id ); 
    }
}

Here is the caller graph for this function:

◆ Bnd_ManMerge()

void Bnd_ManMerge	(	int	id1,
		int	id2,
		int	phaseDiff )

extern

Definition at line 193 of file giaBound.c.

{
 
 
    Vec_Ptr_t* vBmiter2Spec = pBnd -> vBmiter2Spec;
    Vec_Ptr_t* vBmiter2Impl = pBnd -> vBmiter2Impl;
    Vec_Bit_t* vSpec2Impl_phase = pBnd -> vSpec2Impl_phase;
    int id, i;
 
    Vec_Int_t *vIds_spec_repr, *vIds_impl_repr, *vIds_spec_obj, *vIds_impl_obj;
 
    vIds_spec_repr = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Spec, id_repr );
    vIds_impl_repr = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Impl, id_repr );
    vIds_spec_obj = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Spec, id_obj );
    vIds_impl_obj = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Impl, id_obj );
 
    Vec_IntForEachEntry( vIds_spec_obj, id, i )
    {
        Vec_IntPush(vIds_spec_repr, id);
    }
    Vec_IntForEachEntry( vIds_impl_obj, id, i )
    {
        Vec_IntPush(vIds_impl_repr, id);
    }
 
    // handle spec2impl phase
    if ( phaseDiff )
    {
        Vec_IntForEachEntry( vIds_spec_obj, id, i )
        {
            Vec_BitSetEntry( vSpec2Impl_phase, id, !Vec_BitEntry(vSpec2Impl_phase, id) );
            // printf( "spec id %d's phase set to %d\n", id, Vec_BitEntry(vSpec2Impl_phase, id) );
        }
    }
 
    Vec_IntClear(vIds_spec_obj);
    Vec_IntClear(vIds_impl_obj);
 
}

Here is the caller graph for this function:

◆ Bnd_ManPrintMappings()

void Bnd_ManPrintMappings ( )

extern

Definition at line 274 of file giaBound.c.

{
    Vec_Ptr_t* vBmiter2Spec = pBnd -> vBmiter2Spec;
    Vec_Ptr_t* vBmiter2Impl = pBnd -> vBmiter2Impl;
    Vec_Int_t* vIds_spec, *vIds_impl;
    int k, id;
    for( int j=0; j < Vec_PtrSize(vBmiter2Spec); j++ )
    {
        printf("node %d: ", j);
        vIds_spec = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Spec, j);
        vIds_impl = (Vec_Int_t *)Vec_PtrEntry( vBmiter2Impl, j);
        Vec_IntForEachEntry(vIds_spec, id, k)
            printf("%d ", id);
        printf("| ");
        Vec_IntForEachEntry(vIds_impl, id, k)
            printf("%d ", id);
        printf("\n");
    }
 
}

◆ Bnd_ManPrintStats()

void Bnd_ManPrintStats ( )

extern

Definition at line 310 of file giaBound.c.

{
    Bnd_Man_t* p = pBnd;
 
 
    printf("\nSTATS\n");
 
    int warning = 0;
    if ( p->nChoice_spec > 0 )
    {
        warning = 1;
        printf("WARNING: multiple equiv nodes on the boundary of spec\n");
    }
    if ( p->nChoice_impl > 0 )
    {
        warning = 1;
        printf("WARNING: multiple equiv nodes on the boundary of impl\n");
    }
 
    printf("The outsides of spec and impl are %sEQ.\n", p->eq_out ? "" : "NOT " );
    printf("The patched impl is %sEQ. to spec (and impl)\n", p->eq_res ? "" : "NOT " );
 
    // #internal
    // nBI, nBO
    // nBI_miss, nBO_miss
    // nEI, nEO, nExtra
    // #spec, #impl, #patched 
    // combLoop_spec, combLoop_impl
    // #choice_impl
    // #choice_spec
    // #feedthrough
    // warning (may be neq)
    // eq_out, eq_res
 
    printf("\nRESULT\n");
    printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
        p->nInternal,
        p->nBI, p->nBO,
        p->nBI_miss, p->nBO_miss,
        Vec_IntSize(p->vEI_spec), Vec_IntSize(p->vEO_spec), p->nExtra,
        p->nNode_spec, p->nNode_impl, p->nNode_patched,
        p->combLoop_spec, p->combLoop_impl,
        p->nChoice_impl,
        p->nChoice_spec,
        warning,
        p->eq_out, p->eq_res
    );
 
    printf("#Choice Spec\t%d\n", p->nChoice_spec);
    printf("#Choice Impl\t%d\n", p->nChoice_impl);
 
 
 
}

◆ Bnd_ManSetEqOut()

void Bnd_ManSetEqOut ( int eq )

extern

FUNCTION DEFINITIONS ///.

Definition at line 67 of file giaBound.c.

67{ pBnd -> eq_out = eq;}

◆ Bnd_ManSetEqRes()

void Bnd_ManSetEqRes ( int eq )

extern

Definition at line 68 of file giaBound.c.

68{ pBnd -> eq_res = eq;}

◆ Bnd_ManStackGias()

Gia_Man_t * Bnd_ManStackGias	(	Gia_Man_t *	pSpec,
		Gia_Man_t *	pImpl )

extern

Definition at line 1252 of file giaBound.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
 
    int i, iLit;
    if ( Gia_ManBufNum(pSpec) == 0 ) {
        printf( "The spec AIG should have a boundary.\n" );
        return NULL;
    }
    if ( Gia_ManBufNum(pImpl) != 0 ) {
        printf( "The impl AIG should have no boundary.\n" );
        return NULL;
    }
 
    assert( Gia_ManBufNum(pSpec) > 0 );
    assert( Gia_ManBufNum(pImpl) == 0 );
    assert( Gia_ManRegNum(pSpec) == 0 );
    assert( Gia_ManRegNum(pImpl) == 0 );        
    assert( Gia_ManCiNum(pSpec) == Gia_ManCiNum(pImpl) );
    assert( Gia_ManCoNum(pSpec) == Gia_ManCoNum(pImpl) );
 
    pNew = Gia_ManStart( Gia_ManObjNum(pSpec) + Gia_ManObjNum(pImpl) );
    pNew->pName = ABC_ALLOC( char, strlen(pSpec->pName) + 10 );
    sprintf( pNew->pName, "%s_stack", pSpec->pName );
 
    Gia_ManHashStart( pNew );
    Gia_ManConst0(pSpec)->Value = 0;
    Gia_ManConst0(pImpl)->Value = 0;
 
    for( int i = 0; i < Gia_ManCiNum(pSpec); i++ )
    {
        int iLit = Gia_ManCi(pSpec, i)->Value = Gia_ManCi(pImpl, i) -> Value = Gia_ManAppendCi(pNew);
 
        pObj = Gia_ManCi(pSpec, i);
        Bnd_ManMap( iLit, Gia_ObjId( pSpec, pObj ), 1 );
 
        pObj = Gia_ManCi(pImpl, i);
        Bnd_ManMap( iLit, Gia_ObjId( pImpl, pObj) , 0 );
    }
 
    // record the corresponding impl node of each lit
    Gia_ManForEachAnd( pImpl, pObj, i )
    {
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        if ( pBnd ) Bnd_ManMap( pObj -> Value, Gia_ObjId(pImpl, pObj), 0 );
    }
 
    Vec_Int_t* vFlag = Vec_IntAlloc( Gia_ManObjNum( pSpec ) );
    Vec_IntFill( vFlag, Gia_ManObjNum(pSpec), 0 );
    int count = 0;
    Gia_ManForEachBuf( pSpec, pObj, i )
    {
        if ( count < pBnd -> nBI )
        {
            // it's BI, don't record buf
            Vec_IntSetEntry( vFlag,  Gia_ObjId( pSpec, pObj ), 1 );
        }
        else
        {
            // it's BO, don't record buf's fanin
            Vec_IntSetEntry( vFlag,  Gia_ObjId( pSpec, Gia_ObjFanin0( pObj ) ), 1 );
        }
        count++;
    }
 
    // record hashed equivalent nodes
    Gia_ManForEachAnd( pSpec, pObj, i ) 
    {
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        if ( Vec_IntEntry( vFlag, Gia_ObjId( pSpec, pObj ) ) == 0 ) 
        {
            Bnd_ManMap( pObj -> Value, Gia_ObjId(pSpec, pObj), 1 );
        }
    }
    Vec_IntFree( vFlag );
 
    Gia_ManForEachCo( pImpl, pObj, i )
    {
        iLit = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManForEachCo( pSpec, pObj, i )
    {
       iLit = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
 
    // miter
    // Gia_ManForEachCo( pImpl, pObj, i )
    // {
    //     iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManCo(pSpec,i)) );
    //     Gia_ManAppendCo( pNew, iLit );
    // }
 
 
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );    
    return pNew;
}

Here is the call graph for this function:

◆ Bnd_ManStart()

Bnd_Man_t * Bnd_ManStart	(	Gia_Man_t *	pSpec,
		Gia_Man_t *	pImpl,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 88 of file giaBound.c.

{
    int i;
    Bnd_Man_t* p = ABC_CALLOC( Bnd_Man_t, 1 );
 
    p -> maxNumClass = Gia_ManCiNum( pSpec ) + Gia_ManAndNotBufNum(pSpec) + Gia_ManAndNum(pImpl) + 2 + Gia_ManCoNum(pSpec) * 2;
    // one for constant node and one for dummy
 
    p -> vBmiter2Spec = Vec_PtrAlloc( p -> maxNumClass );
    p -> vBmiter2Impl = Vec_PtrAlloc( p -> maxNumClass );
    Vec_PtrFill( p -> vBmiter2Spec, p -> maxNumClass, 0 );
    Vec_PtrFill( p -> vBmiter2Impl, p -> maxNumClass, 0 );
    for( i = 0; i <  Vec_PtrSize( p -> vBmiter2Impl ); i ++ )
    {
        Vec_PtrSetEntry( p -> vBmiter2Spec, i, Vec_IntAlloc(1) );
        Vec_PtrSetEntry( p -> vBmiter2Impl, i, Vec_IntAlloc(1) );
    }
 
    p -> vSpec2Impl_phase = Vec_BitAlloc( Gia_ManObjNum(pSpec) );
    Vec_BitFill( p -> vSpec2Impl_phase, Gia_ManObjNum(pSpec), 0 );
 
    p -> vImpl2Bmiter = Vec_IntAlloc( Gia_ManObjNum(pImpl) );
    Vec_IntFill( p -> vImpl2Bmiter, Gia_ManObjNum(pImpl), p -> maxNumClass - 1 );
    p -> vSpec2Bmiter = Vec_IntAlloc( Gia_ManObjNum(pSpec) );
    Vec_IntFill( p -> vSpec2Bmiter, Gia_ManObjNum(pSpec), p -> maxNumClass - 1);
    
    p -> vBI = Vec_IntAlloc(16);
    p -> vBO = Vec_IntAlloc(16);
    p -> vEI_spec = Vec_IntAlloc(16);
    p -> vEO_spec = Vec_IntAlloc(16);
    p -> vEI_impl = Vec_IntAlloc(16);
    p -> vEO_impl = Vec_IntAlloc(16);
    p -> vEI_phase = Vec_BitAlloc(16);
    p -> vEO_phase = Vec_BitAlloc(16);
 
    p -> nNode_spec = Gia_ManAndNum(pSpec)  - Gia_ManBufNum(pSpec);
    p -> nNode_impl = Gia_ManAndNum(pImpl);
    p -> nNode_patch = 0;
    p -> nNode_patched = 0;
 
    p -> fVerbose = fVerbose;
 
    p -> combLoop_spec = 0;
    p -> combLoop_impl = 0;
    p -> eq_out = 0;
    p -> eq_res = 0;
 
    p -> nChoice_spec = 0;
    p -> nChoice_impl = 0;
    p -> feedthrough = 0;
 
    return p;
}

◆ Bnd_ManStop()

void Bnd_ManStop ( )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 153 of file giaBound.c.

{
    assert(pBnd);
 
    Vec_PtrFree( pBnd-> vBmiter2Spec );
    Vec_PtrFree( pBnd-> vBmiter2Impl );
    Vec_BitFree( pBnd-> vSpec2Impl_phase );
    Vec_IntFree( pBnd-> vImpl2Bmiter );
    Vec_IntFree( pBnd-> vSpec2Bmiter );
 
    Vec_IntFree( pBnd->vBI );
    Vec_IntFree( pBnd->vBO );
    Vec_IntFree( pBnd->vEI_spec );
    Vec_IntFree( pBnd->vEO_spec );
    Vec_IntFree( pBnd->vEI_impl );
    Vec_IntFree( pBnd->vEO_impl );
    Vec_BitFree( pBnd->vEI_phase );
    Vec_BitFree( pBnd->vEO_phase );
 
    ABC_FREE( pBnd );
}

◆ Cbs_ManAlloc()

Cbs_Man_t * Cbs_ManAlloc ( Gia_Man_t * pGia )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 153 of file giaCSat.c.

{
    Cbs_Man_t * p;
    p = ABC_CALLOC( Cbs_Man_t, 1 );
    p->pProp.nSize = p->pJust.nSize = p->pClauses.nSize = 10000;
    p->pProp.pData = ABC_ALLOC( Gia_Obj_t *, p->pProp.nSize );
    p->pJust.pData = ABC_ALLOC( Gia_Obj_t *, p->pJust.nSize );
    p->pClauses.pData = ABC_ALLOC( Gia_Obj_t *, p->pClauses.nSize );
    p->pClauses.iHead = p->pClauses.iTail = 1;
    p->vModel   = Vec_IntAlloc( 1000 );
    p->vLevReas = Vec_IntAlloc( 1000 );
    p->vTemp    = Vec_PtrAlloc( 1000 );
    p->pAig     = pGia;
    Cbs_SetDefaultParams( &p->Pars );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cbs_ManSetConflictNum()

void Cbs_ManSetConflictNum	(	Cbs_Man_t *	p,
		int	Num )

extern

Definition at line 137 of file giaCSat.c.

{
    p->Pars.nBTLimit = Num;
}

◆ Cbs_ManSolve()

int Cbs_ManSolve	(	Cbs_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

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

Synopsis [Looking for a satisfying assignment of the node.]

Description [Assumes that each node has flag pObj->fMark0 set to 0. Returns 1 if unsatisfiable, 0 if satisfiable, and -1 if undecided. The node may be complemented. ]

SideEffects [The two procedures differ in the CEX format.]

SeeAlso []

Definition at line 947 of file giaCSat.c.

{
    int RetValue = 0;
    s_Counter = 0;
    assert( !p->pProp.iHead && !p->pProp.iTail );
    assert( !p->pJust.iHead && !p->pJust.iTail );
    assert( p->pClauses.iHead == 1 && p->pClauses.iTail == 1 );
    p->Pars.nBTThis = p->Pars.nJustThis = p->Pars.nBTThisNc = 0;
    Cbs_ManAssign( p, pObj, 0, NULL, NULL );
    if ( !Cbs_ManSolve_rec(p, 0) && !Cbs_ManCheckLimits(p) )
        Cbs_ManSaveModel( p, p->vModel );
    else
        RetValue = 1;
    Cbs_ManCancelUntil( p, 0 );
    p->pJust.iHead = p->pJust.iTail = 0;
    p->pClauses.iHead = p->pClauses.iTail = 1;
    p->Pars.nBTTotal += p->Pars.nBTThis;
    p->Pars.nJustTotal = Abc_MaxInt( p->Pars.nJustTotal, p->Pars.nJustThis );
    if ( Cbs_ManCheckLimits( p ) )
        RetValue = -1;
//    printf( "%d ", s_Counter );
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cbs_ManSolve2()

int Cbs_ManSolve2	(	Cbs_Man_t *	p,
		Gia_Obj_t *	pObj,
		Gia_Obj_t *	pObj2 )

extern

Definition at line 970 of file giaCSat.c.

{
    int RetValue = 0;
    s_Counter = 0;
    assert( !p->pProp.iHead && !p->pProp.iTail );
    assert( !p->pJust.iHead && !p->pJust.iTail );
    assert( p->pClauses.iHead == 1 && p->pClauses.iTail == 1 );
    p->Pars.nBTThis = p->Pars.nJustThis = p->Pars.nBTThisNc = 0;
    Cbs_ManAssign( p, pObj, 0, NULL, NULL );
    if ( pObj2 ) 
    Cbs_ManAssign( p, pObj2, 0, NULL, NULL );
    if ( !Cbs_ManSolve_rec(p, 0) && !Cbs_ManCheckLimits(p) )
        Cbs_ManSaveModelAll( p, p->vModel );
    else
        RetValue = 1;
    Cbs_ManCancelUntil( p, 0 );
    p->pJust.iHead = p->pJust.iTail = 0;
    p->pClauses.iHead = p->pClauses.iTail = 1;
    p->Pars.nBTTotal += p->Pars.nBTThis;
    p->Pars.nJustTotal = Abc_MaxInt( p->Pars.nJustTotal, p->Pars.nJustThis );
    if ( Cbs_ManCheckLimits( p ) )
        RetValue = -1;
//    printf( "%d ", s_Counter );
    return RetValue;
}

Here is the call graph for this function:

◆ Cbs_ManSolveMiter()

Vec_Int_t * Cbs_ManSolveMiter	(	Gia_Man_t *	pAig,
		int	nConfs,
		Vec_Str_t **	pvStatus,
		int	fVerbose )

extern

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

Synopsis [Procedure to test the new SAT solver.]

Description []

SideEffects []

SeeAlso []

Definition at line 708 of file giaCSatOld.c.

{
    extern void Cec_ManSatAddToStore( Vec_Int_t * vCexStore, Vec_Int_t * vCex, int Out );
    Cbs0_Man_t * p; 
    Vec_Int_t * vCex, * vVisit, * vCexStore;
    Vec_Str_t * vStatus;
    Gia_Obj_t * pRoot; 
    int i, status;
    abctime clk, clkTotal = Abc_Clock();
    assert( Gia_ManRegNum(pAig) == 0 );
    // prepare AIG
    Gia_ManCreateRefs( pAig );
    Gia_ManCleanMark0( pAig );
    Gia_ManCleanMark1( pAig );
    // create logic network
    p = Cbs0_ManAlloc();
    p->Pars.nBTLimit = nConfs;
    p->pAig   = pAig;
    // create resulting data-structures
    vStatus   = Vec_StrAlloc( Gia_ManPoNum(pAig) );
    vCexStore = Vec_IntAlloc( 10000 );
    vVisit    = Vec_IntAlloc( 100 );
    vCex      = Cbs0_ReadModel( p );
    // solve for each output
    Gia_ManForEachCo( pAig, pRoot, i )
    {
        Vec_IntClear( vCex );
        if ( Gia_ObjIsConst0(Gia_ObjFanin0(pRoot)) )
        {
            if ( Gia_ObjFaninC0(pRoot) )
            {
                printf( "Constant 1 output of SRM!!!\n" );
                Cec_ManSatAddToStore( vCexStore, vCex, i ); // trivial counter-example
                Vec_StrPush( vStatus, 0 );
            }
            else
            {
//                printf( "Constant 0 output of SRM!!!\n" );
                Vec_StrPush( vStatus, 1 );
            }
            continue;
        }
        clk = Abc_Clock();
        p->Pars.fUseHighest = 1;
        p->Pars.fUseLowest  = 0;
        status = Cbs0_ManSolve( p, Gia_ObjChild0(pRoot) );
/*
        if ( status == -1 )
        {
            p->Pars.fUseHighest = 0;
            p->Pars.fUseLowest  = 1;
            status = Cbs0_ManSolve( p, Gia_ObjChild0(pRoot) );
        }
*/
        Vec_StrPush( vStatus, (char)status );
        if ( status == -1 )
        {
            p->nSatUndec++;
            p->nConfUndec += p->Pars.nBTThis;
            Cec_ManSatAddToStore( vCexStore, NULL, i ); // timeout
            p->timeSatUndec += Abc_Clock() - clk;
            continue;
        }
        if ( status == 1 )
        {
            p->nSatUnsat++;
            p->nConfUnsat += p->Pars.nBTThis;
            p->timeSatUnsat += Abc_Clock() - clk;
            continue;
        }
        p->nSatSat++;
        p->nConfSat += p->Pars.nBTThis;
//        Gia_SatVerifyPattern( pAig, pRoot, vCex, vVisit );
        Cec_ManSatAddToStore( vCexStore, vCex, i );
        p->timeSatSat += Abc_Clock() - clk;
    }
    Vec_IntFree( vVisit );
    p->nSatTotal = Gia_ManPoNum(pAig);
    p->timeTotal = Abc_Clock() - clkTotal;
    if ( fVerbose )
        Cbs0_ManSatPrintStats( p );
    Cbs0_ManStop( p );
    *pvStatus = vStatus;
//    printf( "Total number of cex literals = %d. (Ave = %d)\n", 
//         Vec_IntSize(vCexStore)-2*p->nSatUndec-2*p->nSatSat, 
//        (Vec_IntSize(vCexStore)-2*p->nSatUndec-2*p->nSatSat)/p->nSatSat );
    return vCexStore;
}

Here is the call graph for this function:

◆ Cbs_ManSolveMiterNc()

Vec_Int_t * Cbs_ManSolveMiterNc	(	Gia_Man_t *	pAig,
		int	nConfs,
		Vec_Str_t **	pvStatus,
		int	f0Proved,
		int	fVerbose )

extern

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

Synopsis [Procedure to test the new SAT solver.]

Description []

SideEffects []

SeeAlso []

Definition at line 1037 of file giaCSat.c.

{
    extern void Gia_ManCollectTest( Gia_Man_t * pAig );
    extern void Cec_ManSatAddToStore( Vec_Int_t * vCexStore, Vec_Int_t * vCex, int Out );
    Cbs_Man_t * p; 
    Vec_Int_t * vCex, * vVisit, * vCexStore;
    Vec_Str_t * vStatus;
    Gia_Obj_t * pRoot; 
    int i, status;
    abctime clk, clkTotal = Abc_Clock();
    assert( Gia_ManRegNum(pAig) == 0 );
//    Gia_ManCollectTest( pAig );
    // prepare AIG
    Gia_ManCreateRefs( pAig );
    Gia_ManCleanMark0( pAig );
    Gia_ManCleanMark1( pAig );
    Gia_ManFillValue( pAig ); // maps nodes into trail ids
    Gia_ManSetPhase( pAig ); // maps nodes into trail ids
    // create logic network
    p = Cbs_ManAlloc( pAig );
    p->Pars.nBTLimit = nConfs;
    // create resulting data-structures
    vStatus   = Vec_StrAlloc( Gia_ManPoNum(pAig) );
    vCexStore = Vec_IntAlloc( 10000 );
    vVisit    = Vec_IntAlloc( 100 );
    vCex      = Cbs_ReadModel( p );
    // solve for each output
    Gia_ManForEachCo( pAig, pRoot, i )
    {
//        printf( "\n" );
 
        Vec_IntClear( vCex );
        if ( Gia_ObjIsConst0(Gia_ObjFanin0(pRoot)) )
        {
            if ( Gia_ObjFaninC0(pRoot) )
            {
//                printf( "Constant 1 output of SRM!!!\n" );
                Cec_ManSatAddToStore( vCexStore, vCex, i ); // trivial counter-example
                Vec_StrPush( vStatus, 0 );
            }
            else
            {
//                printf( "Constant 0 output of SRM!!!\n" );
                Vec_StrPush( vStatus, 1 );
            }
            continue;
        }
        clk = Abc_Clock();
        p->Pars.fUseHighest = 1;
        p->Pars.fUseLowest  = 0;
        status = Cbs_ManSolve( p, Gia_ObjChild0(pRoot) );
//        printf( "\n" );
/*
        if ( status == -1 )
        {
            p->Pars.fUseHighest = 0;
            p->Pars.fUseLowest  = 1;
            status = Cbs_ManSolve( p, Gia_ObjChild0(pRoot) );
        }
*/
        Vec_StrPush( vStatus, (char)status );
        if ( status == -1 )
        {
            p->nSatUndec++;
            p->nConfUndec += p->Pars.nBTThis;
            Cec_ManSatAddToStore( vCexStore, NULL, i ); // timeout
            p->timeSatUndec += Abc_Clock() - clk;
            continue;
        }
        if ( status == 1 )
        {
            if ( f0Proved )
                Gia_ManPatchCoDriver( pAig, i, 0 );
            p->nSatUnsat++;
            p->nConfUnsat += p->Pars.nBTThis;
            p->timeSatUnsat += Abc_Clock() - clk;
            continue;
        }
        p->nSatSat++;
        p->nConfSat += p->Pars.nBTThis;
//        Gia_SatVerifyPattern( pAig, pRoot, vCex, vVisit );
        Cec_ManSatAddToStore( vCexStore, vCex, i );
        p->timeSatSat += Abc_Clock() - clk;
    }
    Vec_IntFree( vVisit );
    p->nSatTotal = Gia_ManPoNum(pAig);
    p->timeTotal = Abc_Clock() - clkTotal;
    if ( fVerbose )
        Cbs_ManSatPrintStats( p );
//    printf( "RecCalls = %8d.  RecClause = %8d.  RecNonChro = %8d.\n", p->nRecCall, p->nRecClause, p->nRecNonChro );
    Cbs_ManStop( p );
    *pvStatus = vStatus;
 
//    printf( "Total number of cex literals = %d. (Ave = %d)\n", 
//         Vec_IntSize(vCexStore)-2*p->nSatUndec-2*p->nSatSat, 
//        (Vec_IntSize(vCexStore)-2*p->nSatUndec-2*p->nSatSat)/p->nSatSat );
    return vCexStore;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cbs_ManStop()

void Cbs_ManStop ( Cbs_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 181 of file giaCSat.c.

{
    Vec_IntFree( p->vLevReas );
    Vec_IntFree( p->vModel );
    Vec_PtrFree( p->vTemp );
    ABC_FREE( p->pClauses.pData );
    ABC_FREE( p->pProp.pData );
    ABC_FREE( p->pJust.pData );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Cbs_ReadModel()

Vec_Int_t * Cbs_ReadModel ( Cbs_Man_t * p )

extern

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

Synopsis [Returns satisfying assignment.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file giaCSat.c.

{
    return p->vModel;
}

Here is the caller graph for this function:

◆ For_ManExperiment()

void For_ManExperiment	(	Gia_Man_t *	pGia,
		int	nIters,
		int	fClustered,
		int	fVerbose )

extern

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

Synopsis [Experiment with the FORCE algorithm.]

Description []

SideEffects []

SeeAlso []

Definition at line 1039 of file giaForce.c.

{
    Frc_Man_t * p;
    Gia_ManRandom( 1 );
    if ( fClustered )
        p = Frc_ManStart( pGia );
    else
        p = Frc_ManStartSimple( pGia );
//    Frc_DumpGraphIntoFile( p );
    if ( fVerbose )
        Frc_ManPrintStats( p );
//    Frc_ManCrossCutTest( p, NULL );
    Frc_ManPlacementRefine( p, nIters, fVerbose );
    Frc_ManStop( p );
}

Here is the call graph for this function:

◆ Gia_AigerRead()

Gia_Man_t * Gia_AigerRead	(	char *	pFileName,
		int	fGiaSimple,
		int	fSkipStrash,
		int	fCheck )

extern

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

Synopsis [Reads the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 1017 of file giaAiger.c.

{
    FILE * pFile;
    Gia_Man_t * pNew;
    char * pName, * pContents;
    int nFileSize;
    int RetValue;
 
    // read the file into the buffer
    Gia_FileFixName( pFileName );
    nFileSize = Gia_FileSize( pFileName );
    pFile = fopen( pFileName, "rb" );
    pContents = ABC_ALLOC( char, nFileSize );
    RetValue = fread( pContents, nFileSize, 1, pFile );
    fclose( pFile );
 
    pNew = Gia_AigerReadFromMemory( pContents, nFileSize, fGiaSimple, fSkipStrash, fCheck );
    ABC_FREE( pContents );
    if ( pNew )
    {
        ABC_FREE( pNew->pName );
        pName = Gia_FileNameGeneric( pFileName );
        pNew->pName = Abc_UtilStrsav( pName );
        ABC_FREE( pName );
 
        assert( pNew->pSpec == NULL );
        pNew->pSpec = Abc_UtilStrsav( pFileName );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_AigerReadFromMemory()

Gia_Man_t * Gia_AigerReadFromMemory	(	char *	pContents,
		int	nFileSize,
		int	fGiaSimple,
		int	fSkipStrash,
		int	fCheck )

extern

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

Synopsis [Reads the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 176 of file giaAiger.c.

{
    Gia_Man_t * pNew, * pTemp;
    Vec_Ptr_t * vNamesIn = NULL, * vNamesOut = NULL, * vNamesRegIn = NULL, * vNamesRegOut = NULL, * vNamesNode = NULL;
    Vec_Int_t * vLits = NULL, * vPoTypes = NULL;
    Vec_Int_t * vNodes, * vDrivers, * vInits = NULL;
    int iObj, iNode0, iNode1, fHieOnly = 0;
    int nTotal, nInputs, nOutputs, nLatches, nAnds, i;
    int nBad = 0, nConstr = 0, nJust = 0, nFair = 0;
    unsigned char * pDrivers, * pSymbols, * pCur;
    unsigned uLit0, uLit1, uLit;
 
    // read the parameters (M I L O A + B C J F)
    pCur = (unsigned char *)pContents;         while ( *pCur != ' ' ) pCur++; pCur++;
    // read the number of objects
    nTotal = atoi( (const char *)pCur );    while ( *pCur != ' ' ) pCur++; pCur++;
    // read the number of inputs
    nInputs = atoi( (const char *)pCur );   while ( *pCur != ' ' ) pCur++; pCur++;
    // read the number of latches
    nLatches = atoi( (const char *)pCur );  while ( *pCur != ' ' ) pCur++; pCur++;
    // read the number of outputs
    nOutputs = atoi( (const char *)pCur );  while ( *pCur != ' ' ) pCur++; pCur++;
    // read the number of nodes
    nAnds = atoi( (const char *)pCur );     while ( *pCur != ' ' && *pCur != '\n' ) pCur++; 
    if ( *pCur == ' ' )
    {
//        assert( nOutputs == 0 );
        // read the number of properties
        pCur++;
        nBad = atoi( (const char *)pCur );     while ( *pCur != ' ' && *pCur != '\n' ) pCur++; 
        nOutputs += nBad;
    }
    if ( *pCur == ' ' )
    {
        // read the number of properties
        pCur++;
        nConstr = atoi( (const char *)pCur );     while ( *pCur != ' ' && *pCur != '\n' ) pCur++; 
        nOutputs += nConstr;
    }
    if ( *pCur == ' ' )
    {
        // read the number of properties
        pCur++;
        nJust = atoi( (const char *)pCur );     while ( *pCur != ' ' && *pCur != '\n' ) pCur++; 
        nOutputs += nJust;
    }
    if ( *pCur == ' ' )
    {
        // read the number of properties
        pCur++;
        nFair = atoi( (const char *)pCur );     while ( *pCur != ' ' && *pCur != '\n' ) pCur++; 
        nOutputs += nFair;
    }
    if ( *pCur != '\n' )
    {
        fprintf( stdout, "The parameter line is in a wrong format.\n" );
        return NULL;
    }
    pCur++;
 
    // check the parameters
    if ( nTotal != nInputs + nLatches + nAnds )
    {
        fprintf( stdout, "The number of objects does not match.\n" );
        return NULL;
    }
    if ( nJust || nFair )
    {
        fprintf( stdout, "Reading AIGER files with liveness properties is currently not supported.\n" );
        return NULL;
    }
 
    if ( nConstr )
    {
        if ( nConstr == 1 )
            fprintf( stdout, "Warning: The last output is interpreted as a constraint.\n" );
        else
            fprintf( stdout, "Warning: The last %d outputs are interpreted as constraints.\n", nConstr );
    }
 
    // allocate the empty AIG
    pNew = Gia_ManStart( nTotal + nLatches + nOutputs + 1 );
    pNew->nConstrs = nConstr;
    pNew->fGiaSimple = fGiaSimple;
 
    // prepare the array of nodes
    vNodes = Vec_IntAlloc( 1 + nTotal );
    Vec_IntPush( vNodes, 0 );
 
    // create the PIs
    for ( i = 0; i < nInputs + nLatches; i++ )
    {
        iObj = Gia_ManAppendCi(pNew);    
        Vec_IntPush( vNodes, iObj );
    }
 
    // remember the beginning of latch/PO literals
    pDrivers = pCur;
    if ( pContents[3] == ' ' ) // standard AIGER
    {
        // scroll to the beginning of the binary data
        for ( i = 0; i < nLatches + nOutputs; )
            if ( *pCur++ == '\n' )
                i++;
    }
    else // modified AIGER
    {
        vLits = Gia_AigerReadLiterals( &pCur, nLatches + nOutputs );
    }
 
    // create the AND gates
    if ( !fGiaSimple && !fSkipStrash )
        Gia_ManHashAlloc( pNew );
    for ( i = 0; i < nAnds; i++ )
    {
        uLit = ((i + 1 + nInputs + nLatches) << 1);
        uLit1 = uLit  - Gia_AigerReadUnsigned( &pCur );
        uLit0 = uLit1 - Gia_AigerReadUnsigned( &pCur );
//        assert( uLit1 > uLit0 );
        iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), uLit0 & 1 );
        iNode1 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit1 >> 1), uLit1 & 1 );
        assert( Vec_IntSize(vNodes) == i + 1 + nInputs + nLatches );
        if ( !fGiaSimple && fSkipStrash )
        {
            if ( iNode0 == iNode1 )
                Vec_IntPush( vNodes, Gia_ManAppendBuf(pNew, iNode0) );
            else
                Vec_IntPush( vNodes, Gia_ManAppendAnd(pNew, iNode0, iNode1) );
        }
        else
            Vec_IntPush( vNodes, Gia_ManHashAnd(pNew, iNode0, iNode1) );
    }
    if ( !fGiaSimple && !fSkipStrash )
        Gia_ManHashStop( pNew );
 
    // remember the place where symbols begin
    pSymbols = pCur;
 
    // read the latch driver literals
    vDrivers = Vec_IntAlloc( nLatches + nOutputs );
    if ( pContents[3] == ' ' ) // standard AIGER
    {
        vInits = Vec_IntAlloc( nLatches );
        pCur = pDrivers;
        for ( i = 0; i < nLatches; i++ )
        {
            uLit0 = atoi( (char *)pCur );   
            while ( *pCur != ' ' && *pCur != '\n' ) 
                pCur++;
            if ( *pCur == ' ' )
            {
                pCur++;
                Vec_IntPush( vInits, atoi( (char *)pCur ) );
                while ( *pCur++ != '\n' );
            }
            else
            {
                pCur++;
                Vec_IntPush( vInits, 0 );
            }
            iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
            Vec_IntPush( vDrivers, iNode0 );
        }
        // read the PO driver literals
        for ( i = 0; i < nOutputs; i++ )
        {
            uLit0 = atoi( (char *)pCur );   while ( *pCur++ != '\n' );
            iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
            Vec_IntPush( vDrivers, iNode0 );
        }
 
    }
    else
    {
        // read the latch driver literals
        for ( i = 0; i < nLatches; i++ )
        {
            uLit0 = Vec_IntEntry( vLits, i );
            iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
            Vec_IntPush( vDrivers, iNode0 );
        }
        // read the PO driver literals
        for ( i = 0; i < nOutputs; i++ )
        {
            uLit0 = Vec_IntEntry( vLits, i+nLatches );
            iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
            Vec_IntPush( vDrivers, iNode0 );
        }
        Vec_IntFree( vLits );
    }
 
    // create the POs
    for ( i = 0; i < nOutputs; i++ )
        Gia_ManAppendCo( pNew, Vec_IntEntry(vDrivers, nLatches + i) );
    for ( i = 0; i < nLatches; i++ )
        Gia_ManAppendCo( pNew, Vec_IntEntry(vDrivers, i) );
    Vec_IntFree( vDrivers );
 
    // create the latches
    Gia_ManSetRegNum( pNew, nLatches );
 
    // read signal names if they are of the special type
    pCur = pSymbols;
    if ( pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
    {
        int fReadNames = 1;
        if ( fReadNames )
        {
            int fError = 0;
            while ( !fError && pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
            {
                int iTerm;
                char * pType = (char *)pCur;
                char * pName = NULL;
                // check terminal type
                if ( *pCur != 'i' && *pCur != 'o' && *pCur != 'l' && *pCur != 'n' )
                {
                    fError = 1;
                    break;
                }
                // get terminal number
                iTerm = atoi( (char *)++pCur );  while ( *pCur++ != ' ' );
                // skip spaces
                while ( *pCur == ' ' )
                    pCur++;
                // skip till the end of line
                for ( pName = (char *)pCur; *pCur && *pCur != '\n'; pCur++ );
                if ( *pCur == '\n' )
                    *pCur = 0;
                // save the name
                if ( *pType == 'i' )
                {
                    if ( vNamesIn == NULL )
                        vNamesIn = Vec_PtrStart( nInputs );
                    if ( Vec_PtrSize(vNamesIn) <= iTerm )
                    {
                        fError = 1;
                        break;
                    }
                    Vec_PtrWriteEntry( vNamesIn, iTerm, Abc_UtilStrsav(pName) );
                }
                else if ( *pType == 'o' )
                {
                    if ( vNamesOut == NULL )
                        vNamesOut = Vec_PtrStart( nOutputs );
                    if ( Vec_PtrSize(vNamesOut) <= iTerm )
                    {
                        fError = 1;
                        break;
                    }
                    Vec_PtrWriteEntry( vNamesOut, iTerm,  Abc_UtilStrsav(pName) );
                }
                else if ( *pType == 'l' )
                {
                    char Buffer[1000];
                    assert( strlen(pName) < 995 );
                    sprintf( Buffer, "%s_in", pName );
                    if ( vNamesRegIn == NULL )
                        vNamesRegIn = Vec_PtrStart( nLatches );
                    if ( vNamesRegOut == NULL )
                        vNamesRegOut = Vec_PtrStart( nLatches );
                    if ( Vec_PtrSize(vNamesRegIn) <= iTerm )
                    {
                        fError = 1;
                        break;
                    }
                    Vec_PtrWriteEntry( vNamesRegIn,  iTerm, Abc_UtilStrsav(Buffer) );
                    Vec_PtrWriteEntry( vNamesRegOut, iTerm, Abc_UtilStrsav(pName) );
                }
                else if ( *pType == 'n' )
                {
                    if ( Vec_IntSize(&pNew->vHTable) != 0 )
                    {
                        printf( "Structural hashing should be disabled to read internal nodes names.\n" );
                        fError = 1;
                        break;
                    }
                    if ( vNamesNode == NULL )
                        vNamesNode = Vec_PtrStart( Gia_ManObjNum(pNew) );
                    Vec_PtrWriteEntry( vNamesNode, iTerm, Abc_UtilStrsav(pName) );
                }
                else
                {
                    fError = 1;
                    break;
                }
                pCur++;
            }
            if ( fError )
            {
                printf( "Error occurred when reading signal names. Signal names ignored.\n" );
                if ( vNamesIn ) Vec_PtrFreeFree( vNamesIn ), vNamesIn = NULL;
                if ( vNamesOut ) Vec_PtrFreeFree( vNamesOut ), vNamesOut = NULL;
                if ( vNamesRegIn ) Vec_PtrFreeFree( vNamesRegIn ), vNamesRegIn = NULL;
                if ( vNamesRegOut ) Vec_PtrFreeFree( vNamesRegOut ), vNamesRegOut = NULL;
                if ( vNamesNode )    Vec_PtrFreeFree( vNamesNode ),    vNamesNode = NULL;
            }
        }
        else
        {
        int fBreakUsed = 0;
        unsigned char * pCurOld = pCur;
        pNew->vUserPiIds = Vec_IntStartFull( nInputs );
        pNew->vUserPoIds = Vec_IntStartFull( nOutputs );
        pNew->vUserFfIds = Vec_IntStartFull( nLatches );
        while ( pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
        {
            int iTerm;
            char * pType = (char *)pCur;
            // check terminal type
            if ( *pCur != 'i' && *pCur != 'o' && *pCur != 'l'  )
            {
//                fprintf( stdout, "Wrong terminal type.\n" );
                fBreakUsed = 1;
                break;
            }
            // get terminal number
            iTerm = atoi( (char *)++pCur );  while ( *pCur++ != ' ' );
            // skip spaces
            while ( *pCur == ' ' )
                pCur++;
            // decode the user numbers:
            // flops are named: @l<num>
            // PIs are named: @i<num>
            // POs are named: @o<num>
            if ( *pCur++ != '@' )
            {
                fBreakUsed = 1;
                break;
            }
            if ( *pCur == 'i' && *pType == 'i' )
                Vec_IntWriteEntry( pNew->vUserPiIds, iTerm, atoi((char *)pCur+1) );
            else if ( *pCur == 'o' && *pType == 'o' )
                Vec_IntWriteEntry( pNew->vUserPoIds, iTerm, atoi((char *)pCur+1) );
            else if ( *pCur == 'l' && *pType == 'l' )
                Vec_IntWriteEntry( pNew->vUserFfIds, iTerm, atoi((char *)pCur+1) );
            else
            {
                fprintf( stdout, "Wrong name format.\n" );
                fBreakUsed = 1;
                break;
            }
            // skip digits
            while ( *pCur++ != '\n' );
        }
        // in case of abnormal termination, remove the arrays
        if ( fBreakUsed )
        {
            unsigned char * pName;
            int Entry, nInvars, nConstr, iTerm;
 
            Vec_Int_t * vPoNames = Vec_IntStartFull( nOutputs );
 
            Vec_IntFreeP( &pNew->vUserPiIds );
            Vec_IntFreeP( &pNew->vUserPoIds );
            Vec_IntFreeP( &pNew->vUserFfIds );
 
            // try to figure out signal names
            fBreakUsed = 0;
            pCur = (unsigned char *)pCurOld;
            while ( pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
            {
                // get the terminal type
                if ( *pCur == 'i' || *pCur == 'l' )
                {
                    // skip till the end of the line
                    while ( *pCur++ != '\n' );
                    *(pCur-1) = 0;
                    continue;
                }
                if ( *pCur != 'o' )
                {
//                    fprintf( stdout, "Wrong terminal type.\n" );
                    fBreakUsed = 1;
                    break;
                }
                // get the terminal number
                iTerm = atoi( (char *)++pCur );  while ( *pCur++ != ' ' );
                // get the node
                if ( iTerm < 0 || iTerm >= nOutputs )
                {
                    fprintf( stdout, "The output number (%d) is out of range.\n", iTerm );
                    fBreakUsed = 1;
                    break;
                }
                if ( Vec_IntEntry(vPoNames, iTerm) != ~0 )
                {
                    fprintf( stdout, "The output number (%d) is listed twice.\n", iTerm );
                    fBreakUsed = 1;
                    break;
                }
 
                // get the name
                pName = pCur;          while ( *pCur++ != '\n' );
                *(pCur-1) = 0;
                // assign the name
                Vec_IntWriteEntry( vPoNames, iTerm, pName - (unsigned char *)pContents );
            } 
 
            // check that all names are assigned
            if ( !fBreakUsed )
            {
                nInvars = nConstr = 0;
                vPoTypes = Vec_IntStart( Gia_ManPoNum(pNew) );
                Vec_IntForEachEntry( vPoNames, Entry, i )
                {
                    if ( Entry == ~0 )
                        continue;
                    if ( strncmp( pContents+Entry, "constraint:", 11 ) == 0 )
                    {
                        Vec_IntWriteEntry( vPoTypes, i, 1 );
                        nConstr++;
                    }
                    if ( strncmp( pContents+Entry, "invariant:", 10 ) == 0 )
                    {
                        Vec_IntWriteEntry( vPoTypes, i, 2 );
                        nInvars++;
                    }
                }
                if ( nConstr )
                    fprintf( stdout, "Recognized and added %d constraints.\n", nConstr );
                if ( nInvars )
                    fprintf( stdout, "Recognized and skipped %d invariants.\n", nInvars );
                if ( nConstr == 0 && nInvars == 0 )
                    Vec_IntFreeP( &vPoTypes );
            }
            Vec_IntFree( vPoNames );
        }
        }
    }
 
 
    // check if there are other types of information to read
    if ( pCur + 1 < (unsigned char *)pContents + nFileSize && *pCur == 'c' )
    {
        int fVerbose = XAIG_VERBOSE;
        Vec_Str_t * vStr;
        unsigned char * pCurTemp;
        pCur++;
        // skip new line if present
//        if ( *pCur == '\n' )
//            pCur++;
        while ( pCur < (unsigned char *)pContents + nFileSize )
        {
            // read extra AIG
            if ( *pCur == 'a' )
            {
                pCur++;
                vStr = Vec_StrStart( Gia_AigerReadInt(pCur) );             pCur += 4;
                memcpy( Vec_StrArray(vStr), pCur, (size_t)Vec_StrSize(vStr) );
                pCur += Vec_StrSize(vStr);
                pNew->pAigExtra = Gia_AigerReadFromMemory( Vec_StrArray(vStr), Vec_StrSize(vStr), 0, 0, 0 );
                Vec_StrFree( vStr );
                if ( fVerbose ) printf( "Finished reading extension \"a\".\n" );
            }
            // read number of constraints
            else if ( *pCur == 'c' )
            {
                pCur++;
                assert( Gia_AigerReadInt(pCur) == 4 );                     pCur += 4;
                pNew->nConstrs = Gia_AigerReadInt( pCur );                 pCur += 4;
                if ( fVerbose ) printf( "Finished reading extension \"c\".\n" );
            }
            // read delay information
            else if ( *pCur == 'd' )
            {
                pCur++;
                assert( Gia_AigerReadInt(pCur) == 4 );                     pCur += 4;
                pNew->nAnd2Delay = Gia_AigerReadInt(pCur);                 pCur += 4;
                if ( fVerbose ) printf( "Finished reading extension \"d\".\n" );
            }
            else if ( *pCur == 'i' )
            {
                pCur++;
                nInputs = Gia_AigerReadInt(pCur)/4;                        pCur += 4;
                pNew->vInArrs  = Vec_FltStart( nInputs );
                memcpy( Vec_FltArray(pNew->vInArrs),  pCur, (size_t)4*nInputs );   pCur += 4*nInputs;
                if ( fVerbose ) printf( "Finished reading extension \"i\".\n" );
            }
            else if ( *pCur == 'o' )
            {
                pCur++;
                nOutputs = Gia_AigerReadInt(pCur)/4;                       pCur += 4;
                pNew->vOutReqs  = Vec_FltStart( nOutputs );
                memcpy( Vec_FltArray(pNew->vOutReqs),  pCur, (size_t)4*nOutputs ); pCur += 4*nOutputs;
                if ( fVerbose ) printf( "Finished reading extension \"o\".\n" );
            }
            // read equivalence classes
            else if ( *pCur == 'e' )
            {
                extern Gia_Rpr_t * Gia_AigerReadEquivClasses( unsigned char ** ppPos, int nSize );
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;              pCur += 4;
                pNew->pReprs = Gia_AigerReadEquivClasses( &pCur, Gia_ManObjNum(pNew) );
                pNew->pNexts = Gia_ManDeriveNexts( pNew );
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"e\".\n" );
            }
            // read flop classes
            else if ( *pCur == 'f' )
            {
                pCur++;
                assert( Gia_AigerReadInt(pCur) == 4*Gia_ManRegNum(pNew) );   pCur += 4;
                pNew->vFlopClasses  = Vec_IntStart( Gia_ManRegNum(pNew) );
                memcpy( Vec_IntArray(pNew->vFlopClasses),  pCur, (size_t)4*Gia_ManRegNum(pNew) );   pCur += 4*Gia_ManRegNum(pNew);
                if ( fVerbose ) printf( "Finished reading extension \"f\".\n" );
            }
            // read gate classes
            else if ( *pCur == 'g' )
            {
                pCur++;
                assert( Gia_AigerReadInt(pCur) == 4*Gia_ManObjNum(pNew) );   pCur += 4;
                pNew->vGateClasses  = Vec_IntStart( Gia_ManObjNum(pNew) );
                memcpy( Vec_IntArray(pNew->vGateClasses),  pCur, (size_t)4*Gia_ManObjNum(pNew) );   pCur += 4*Gia_ManObjNum(pNew);
                if ( fVerbose ) printf( "Finished reading extension \"g\".\n" );
            }
            // read hierarchy information
            else if ( *pCur == 'h' )
            {
                pCur++;
                vStr = Vec_StrStart( Gia_AigerReadInt(pCur) );          pCur += 4;
                memcpy( Vec_StrArray(vStr), pCur, (size_t)Vec_StrSize(vStr) );
                pCur += Vec_StrSize(vStr);
                pNew->pManTime = Tim_ManLoad( vStr, 1 );
                Vec_StrFree( vStr );
                fHieOnly = 1;
                if ( fVerbose ) printf( "Finished reading extension \"h\".\n" );
            }
            // read packing
            else if ( *pCur == 'k' )
            {
                extern Vec_Int_t * Gia_AigerReadPacking( unsigned char ** ppPos, int nSize );
                int nSize;
                pCur++;
                nSize = Gia_AigerReadInt(pCur);
                pCurTemp = pCur + nSize + 4;                            pCur += 4;
                pNew->vPacking = Gia_AigerReadPacking( &pCur, nSize ); 
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"k\".\n" );
            }
            // read mapping
            else if ( *pCur == 'm' )
            {
                extern int * Gia_AigerReadMapping( unsigned char ** ppPos, int nSize );
                extern int * Gia_AigerReadMappingSimple( unsigned char ** ppPos, int nSize );
                extern Vec_Int_t * Gia_AigerReadMappingDoc( unsigned char ** ppPos, int nObjs );
                int nSize;
                pCur++;
                nSize = Gia_AigerReadInt(pCur);
                pCurTemp = pCur + nSize + 4;           pCur += 4;
                pNew->vMapping = Gia_AigerReadMappingDoc( &pCur, Gia_ManObjNum(pNew) );
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"m\".\n" );
            }
            // read model name
            else if ( *pCur == 'n' )
            {
                pCur++;
                if ( (*pCur >= 'a' && *pCur <= 'z') || (*pCur >= 'A' && *pCur <= 'Z') || (*pCur >= '0' && *pCur <= '9') )
                {
                    ABC_FREE( pNew->pName );
                    pNew->pName = Abc_UtilStrsav( (char *)pCur );       pCur += strlen(pNew->pName) + 1;
                }
                else
                {
                    pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;       pCur += 4;
                    ABC_FREE( pNew->pName );
                    pNew->pName = Abc_UtilStrsav( (char *)pCur );       pCur += strlen(pNew->pName) + 1;
                    assert( pCur == pCurTemp );
                }
            }
            // read placement
            else if ( *pCur == 'p' )
            {
                Gia_Plc_t * pPlacement;
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                pPlacement = ABC_ALLOC( Gia_Plc_t, Gia_ManObjNum(pNew) );
                memcpy( pPlacement, pCur, (size_t)4*Gia_ManObjNum(pNew) );      pCur += 4*Gia_ManObjNum(pNew);
                assert( pCur == pCurTemp );
                pNew->pPlacement = pPlacement;
                if ( fVerbose ) printf( "Finished reading extension \"p\".\n" );
            }
            // read register classes
            else if ( *pCur == 'r' )
            {
                int i, nRegs;
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                nRegs = Gia_AigerReadInt(pCur);                         pCur += 4;
                //nRegs = (pCurTemp - pCur)/4;
                pNew->vRegClasses = Vec_IntAlloc( nRegs );
                for ( i = 0; i < nRegs; i++ )
                    Vec_IntPush( pNew->vRegClasses, Gia_AigerReadInt(pCur) ), pCur += 4;
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"r\".\n" );
            }
            // read register inits
            else if ( *pCur == 's' )
            {
                int i, nRegs;
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                nRegs = Gia_AigerReadInt(pCur);                         pCur += 4;
                pNew->vRegInits = Vec_IntAlloc( nRegs );
                for ( i = 0; i < nRegs; i++ )
                    Vec_IntPush( pNew->vRegInits, Gia_AigerReadInt(pCur) ), pCur += 4;
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"s\".\n" );
            }
            // read configuration data
            else if ( *pCur == 'b' )
            {
                int nSize;
                pCur++;
                nSize = Gia_AigerReadInt(pCur);
                pCurTemp = pCur + nSize + 4;                            pCur += 4;
                pNew->pCellStr = Abc_UtilStrsav( (char*)pCur );         pCur += strlen((char*)pCur) + 1;
                nSize = nSize - strlen(pNew->pCellStr) - 1;
                assert( nSize % 4 == 0 );
                pNew->vConfigs = Vec_IntAlloc(nSize / 4);
//                memcpy(Vec_IntArray(pNew->vConfigs), pCur, (size_t)nSize);      pCur += nSize;
                for ( i = 0; i < nSize / 4; i++ )
                    Vec_IntPush( pNew->vConfigs, Gia_AigerReadInt(pCur) ), pCur += 4;
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"b\".\n" );
            }
            // read choices
            else if ( *pCur == 'q' )
            {
                int i, nPairs, iRepr, iNode;
                assert( !Gia_ManHasChoices(pNew) );
                pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(pNew) );
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                nPairs = Gia_AigerReadInt(pCur);                        pCur += 4;
                for ( i = 0; i < nPairs; i++ )
                {
                    iRepr = Gia_AigerReadInt(pCur);                     pCur += 4;
                    iNode = Gia_AigerReadInt(pCur);                     pCur += 4;
                    pNew->pSibls[iRepr] = iNode;
                    assert( iRepr > iNode );
                }
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"q\".\n" );
            }
            // read switching activity
            else if ( *pCur == 'u' )
            { 
                unsigned char * pSwitching;
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                pSwitching = ABC_ALLOC( unsigned char, Gia_ManObjNum(pNew) );
                memcpy( pSwitching, pCur, (size_t)Gia_ManObjNum(pNew) );        pCur += Gia_ManObjNum(pNew);
                assert( pCur == pCurTemp );
                if ( fVerbose ) printf( "Finished reading extension \"s\".\n" );
            }
            // read timing manager
            else if ( *pCur == 't' )
            {
                pCur++;
                vStr = Vec_StrStart( Gia_AigerReadInt(pCur) );          pCur += 4;
                memcpy( Vec_StrArray(vStr), pCur, (size_t)Vec_StrSize(vStr) );  pCur += Vec_StrSize(vStr);
                pNew->pManTime = Tim_ManLoad( vStr, 0 );
                Vec_StrFree( vStr );
                if ( fVerbose ) printf( "Finished reading extension \"t\".\n" );
            }
            // read object classes
            else if ( *pCur == 'v' )
            {
                pCur++;
                pNew->vObjClasses = Vec_IntStart( Gia_AigerReadInt(pCur)/4 ); pCur += 4;
                memcpy( Vec_IntArray(pNew->vObjClasses), pCur, (size_t)4*Vec_IntSize(pNew->vObjClasses) );
                pCur += 4*Vec_IntSize(pNew->vObjClasses);
                if ( fVerbose ) printf( "Finished reading extension \"v\".\n" );
            }
            // read edge information
            else if ( *pCur == 'w' )
            {
                Vec_Int_t * vPairs;
                int i, nPairs;
                pCur++;
                pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4;           pCur += 4;
                nPairs = Gia_AigerReadInt(pCur);                        pCur += 4;
                vPairs = Vec_IntAlloc( 2*nPairs );
                for ( i = 0; i < 2*nPairs; i++ )
                    Vec_IntPush( vPairs, Gia_AigerReadInt(pCur) ),      pCur += 4;
                assert( pCur == pCurTemp );
                if ( fSkipStrash )
                {
                    Gia_ManEdgeFromArray( pNew, vPairs );
                    if ( fVerbose ) printf( "Finished reading extension \"w\".\n" );
                }
                else
                    printf( "Cannot read extension \"w\" because AIG is rehashed. Use \"&r -s <file.aig>\".\n" );
                Vec_IntFree( vPairs );
            }
            else break;
        }
    }
 
    // skipping the comments
    Vec_IntFree( vNodes );
 
    // update polarity of the additional outputs
    if ( nBad || nConstr || nJust || nFair )
        Gia_ManInvertConstraints( pNew );
 
    // clean the PO drivers
    if ( vPoTypes )
    {
        pNew = Gia_ManDupWithConstraints( pTemp = pNew, vPoTypes );
        Gia_ManStop( pTemp );
        Vec_IntFreeP( &vPoTypes );
    }
 
    if ( !fGiaSimple && !fSkipStrash && Gia_ManHasDangling(pNew) )
    {
        Tim_Man_t * pManTime;
        Gia_Man_t * pAigExtra;
        Vec_Int_t * vFlopMap, * vGateMap, * vObjMap, * vRegClasses, * vRegInits;
        vRegClasses = pNew->vRegClasses;  pNew->vRegClasses    = NULL;
        vRegInits   = pNew->vRegInits;    pNew->vRegInits      = NULL;
        vFlopMap    = pNew->vFlopClasses; pNew->vFlopClasses   = NULL;
        vGateMap    = pNew->vGateClasses; pNew->vGateClasses   = NULL;
        vObjMap     = pNew->vObjClasses;  pNew->vObjClasses    = NULL;
        pManTime = (Tim_Man_t *)pNew->pManTime; pNew->pManTime = NULL;
        pAigExtra   = pNew->pAigExtra;    pNew->pAigExtra      = NULL;
        pNew = Gia_ManCleanup( pTemp = pNew );
        if ( (vGateMap || vObjMap) && (Gia_ManObjNum(pNew) < Gia_ManObjNum(pTemp)) )
            printf( "Cleanup removed objects after reading. Old gate/object abstraction maps are invalid!\n" );
        Gia_ManStop( pTemp );
        pNew->vRegClasses  = vRegClasses;
        pNew->vRegInits    = vRegInits;
        pNew->vFlopClasses = vFlopMap;
        pNew->vGateClasses = vGateMap;
        pNew->vObjClasses  = vObjMap;
        pNew->pManTime     = pManTime;
        pNew->pAigExtra    = pAigExtra;
    }
 
    if ( fHieOnly )
    {
//        Tim_ManPrint( (Tim_Man_t *)pNew->pManTime );
        if ( Abc_FrameReadLibBox() == NULL )
            printf( "Warning: Creating unit-delay box delay tables because box library is not available.\n" );
        Tim_ManCreate( (Tim_Man_t *)pNew->pManTime, Abc_FrameReadLibBox(), pNew->vInArrs, pNew->vOutReqs );
    }
    Vec_FltFreeP( &pNew->vInArrs );
    Vec_FltFreeP( &pNew->vOutReqs );
/*
    // check the result
    if ( fCheck && !Gia_ManCheck( pNew ) )
    {
        printf( "Gia_AigerRead: The network check has failed.\n" );
        Gia_ManStop( pNew );
        return NULL;
    }
*/
 
    if ( vInits && Vec_IntSum(vInits) )
    {
        char * pInit = ABC_ALLOC( char, Vec_IntSize(vInits) + 1 );
        Gia_Obj_t * pObj;
        int i;
        assert( Vec_IntSize(vInits) == Gia_ManRegNum(pNew) );
        Gia_ManForEachRo( pNew, pObj, i )
        {
            if ( Vec_IntEntry(vInits, i) == 0 )
                pInit[i] = '0';
            else if ( Vec_IntEntry(vInits, i) == 1 )
                pInit[i] = '1';
            else 
            {
                assert( Vec_IntEntry(vInits, i) == Abc_Var2Lit(Gia_ObjId(pNew, pObj), 0) );
                // unitialized value of the latch is the latch literal according to http://fmv.jku.at/hwmcc11/beyond1.pdf
                pInit[i] = 'X';
            }
        }
        pInit[i] = 0;
        if ( !fSkipStrash ) 
        {
            pNew = Gia_ManDupZeroUndc( pTemp = pNew, pInit, 0, fGiaSimple, 1 );
            pNew->nConstrs = pTemp->nConstrs; pTemp->nConstrs = 0;
            Gia_ManStop( pTemp );
        }
        ABC_FREE( pInit );
    }
    Vec_IntFreeP( &vInits );
    if ( !fGiaSimple && !fSkipStrash && pNew->vMapping )
    {
        Abc_Print( 0, "Structural hashing enabled while reading AIGER invalidated the mapping.  Consider using \"&r -s\".\n" );
        Vec_IntFreeP( &pNew->vMapping );
    }
    if ( vNamesIn && Gia_ManPiNum(pNew) != Vec_PtrSize(vNamesIn) )
        Abc_Print( 0, "The number of inputs does not match the number of input names.\n" );
    else if ( vNamesOut && Gia_ManPoNum(pNew) != Vec_PtrSize(vNamesOut) )
        Abc_Print( 0, "The number of output does not match the number of output names.\n" );
    else if ( vNamesRegOut && Gia_ManRegNum(pNew) != Vec_PtrSize(vNamesRegOut) )
        Abc_Print( 0, "The number of inputs does not match the number of flop names.\n" );
    else if ( vNamesIn && vNamesOut )
    {
        pNew->vNamesIn  = vNamesIn;   vNamesIn = NULL;
        pNew->vNamesOut = vNamesOut;  vNamesOut = NULL;
        if ( vNamesRegOut )
        {
            Vec_PtrAppend( pNew->vNamesIn, vNamesRegOut );
            Vec_PtrClear( vNamesRegOut );
            Vec_PtrFree( vNamesRegOut );
            vNamesRegOut = NULL;
        }
        if ( vNamesRegIn )
        {
            Vec_PtrAppend( pNew->vNamesOut, vNamesRegIn );
            Vec_PtrClear( vNamesRegIn );
            Vec_PtrFree( vNamesRegIn );
            vNamesRegIn = NULL;
        }
    }
    if ( vNamesNode && Gia_ManObjNum(pNew) != Vec_PtrSize(vNamesNode) )
        Abc_Print( 0, "The size of the node name array does not match the number of objects. Names are not entered.\n" );
    else if ( vNamesNode )
        pNew->vNamesNode = vNamesNode, vNamesNode = NULL;
    if ( vNamesIn ) Vec_PtrFreeFree( vNamesIn );
    if ( vNamesOut ) Vec_PtrFreeFree( vNamesOut );
    if ( vNamesRegIn ) Vec_PtrFreeFree( vNamesRegIn );
    if ( vNamesRegOut ) Vec_PtrFreeFree( vNamesRegOut );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_AigerWrite()

void Gia_AigerWrite	(	Gia_Man_t *	pInit,
		char *	pFileName,
		int	fWriteSymbols,
		int	fCompact,
		int	fWriteNewLine )

extern

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

Synopsis [Writes the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 1595 of file giaAiger.c.

{
     Gia_AigerWriteS( pInit, pFileName, fWriteSymbols, fCompact, fWriteNewLine, 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_AigerWriteIntoMemoryStr()

Vec_Str_t * Gia_AigerWriteIntoMemoryStr ( Gia_Man_t * p )

extern

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

Synopsis [Writes the AIG in into the memory buffer.]

Description [The resulting buffer constains the AIG in AIGER format. The resulting buffer should be deallocated by the user.]

SideEffects []

SeeAlso []

Definition at line 1062 of file giaAiger.c.

{
    Vec_Str_t * vBuffer;
    Gia_Obj_t * pObj;
    int nNodes = 0, i, uLit, uLit0, uLit1; 
    // set the node numbers to be used in the output file
    Gia_ManConst0(p)->Value = nNodes++;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = nNodes++;
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = nNodes++;
 
    // write the header "M I L O A" where M = I + L + A
    vBuffer = Vec_StrAlloc( 3*Gia_ManObjNum(p) );
    Vec_StrPrintStr( vBuffer, "aig " );
    Vec_StrPrintNum( vBuffer, Gia_ManCandNum(p) );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Gia_ManPiNum(p) );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Gia_ManRegNum(p) );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Gia_ManPoNum(p) );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Gia_ManAndNum(p) );
    Vec_StrPrintStr( vBuffer, "\n" );
 
    // write latch drivers
    Gia_ManForEachRi( p, pObj, i )
    {
        uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
        Vec_StrPrintNum( vBuffer, uLit );
        Vec_StrPrintStr( vBuffer, "\n" );
    }
 
    // write PO drivers
    Gia_ManForEachPo( p, pObj, i )
    {
        uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
        Vec_StrPrintNum( vBuffer, uLit );
        Vec_StrPrintStr( vBuffer, "\n" );
    }
    // write the nodes into the buffer
    Gia_ManForEachAnd( p, pObj, i )
    {
        uLit  = Abc_Var2Lit( Gia_ObjValue(pObj), 0 );
        uLit0 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
        uLit1 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj) );
        assert( uLit0 != uLit1 );
        if ( uLit0 > uLit1 )
        {
            int Temp = uLit0;
            uLit0 = uLit1;
            uLit1 = Temp;
        }
        Gia_AigerWriteUnsigned( vBuffer, uLit  - uLit1 );
        Gia_AigerWriteUnsigned( vBuffer, uLit1 - uLit0 );
    }
    Vec_StrPrintStr( vBuffer, "c" );
    return vBuffer;
}

Here is the caller graph for this function:

◆ Gia_AigerWriteIntoMemoryStrPart()

Vec_Str_t * Gia_AigerWriteIntoMemoryStrPart	(	Gia_Man_t *	p,
		Vec_Int_t *	vCis,
		Vec_Int_t *	vAnds,
		Vec_Int_t *	vCos,
		int	nRegs )

extern

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

Synopsis [Writes the AIG in into the memory buffer.]

Description [The resulting buffer constains the AIG in AIGER format. The CI/CO/AND nodes are assumed to be ordered according to some rule. The resulting buffer should be deallocated by the user.]

SideEffects [Note that in vCos, PIs are order first, followed by latches!]

SeeAlso []

Definition at line 1136 of file giaAiger.c.

{
    Vec_Str_t * vBuffer;
    Gia_Obj_t * pObj;
    int nNodes = 0, i, uLit, uLit0, uLit1; 
    // set the node numbers to be used in the output file
    Gia_ManConst0(p)->Value = nNodes++;
    Gia_ManForEachObjVec( vCis, p, pObj, i )
    {
        assert( Gia_ObjIsCi(pObj) );
        pObj->Value = nNodes++;
    }
    Gia_ManForEachObjVec( vAnds, p, pObj, i )
    {
        assert( Gia_ObjIsAnd(pObj) );
        pObj->Value = nNodes++;
    }
 
    // write the header "M I L O A" where M = I + L + A
    vBuffer = Vec_StrAlloc( 3*Gia_ManObjNum(p) );
    Vec_StrPrintStr( vBuffer, "aig " );
    Vec_StrPrintNum( vBuffer, Vec_IntSize(vCis) + Vec_IntSize(vAnds) );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Vec_IntSize(vCis) - nRegs );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, nRegs );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Vec_IntSize(vCos) - nRegs );
    Vec_StrPrintStr( vBuffer, " " );
    Vec_StrPrintNum( vBuffer, Vec_IntSize(vAnds) );
    Vec_StrPrintStr( vBuffer, "\n" );
 
    // write latch drivers
    Gia_ManForEachObjVec( vCos, p, pObj, i )
    {
        assert( Gia_ObjIsCo(pObj) );
        if ( i < Vec_IntSize(vCos) - nRegs )
            continue;
        uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
        Vec_StrPrintNum( vBuffer, uLit );
        Vec_StrPrintStr( vBuffer, "\n" );
    }
    // write output drivers
    Gia_ManForEachObjVec( vCos, p, pObj, i )
    {
        assert( Gia_ObjIsCo(pObj) );
        if ( i >= Vec_IntSize(vCos) - nRegs )
            continue;
        uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
        Vec_StrPrintNum( vBuffer, uLit );
        Vec_StrPrintStr( vBuffer, "\n" );
    }
 
    // write the nodes into the buffer
    Gia_ManForEachObjVec( vAnds, p, pObj, i )
    {
        uLit  = Abc_Var2Lit( Gia_ObjValue(pObj), 0 );
        uLit0 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
        uLit1 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj) );
        assert( uLit0 != uLit1 );
        if ( uLit0 > uLit1 )
        {
            int Temp = uLit0;
            uLit0 = uLit1;
            uLit1 = Temp;
        }
        Gia_AigerWriteUnsigned( vBuffer, uLit  - uLit1 );
        Gia_AigerWriteUnsigned( vBuffer, uLit1 - uLit0 );
    }
    Vec_StrPrintStr( vBuffer, "c" );
    return vBuffer;
}

Here is the caller graph for this function:

◆ Gia_AigerWriteS()

void Gia_AigerWriteS	(	Gia_Man_t *	pInit,
		char *	pFileName,
		int	fWriteSymbols,
		int	fCompact,
		int	fWriteNewLine,
		int	fSkipComment )

extern

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

Synopsis [Writes the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 1220 of file giaAiger.c.

{
    int fVerbose = XAIG_VERBOSE;
    FILE * pFile;
    Gia_Man_t * p;
    Gia_Obj_t * pObj;
    Vec_Str_t * vStrExt;
    int i, nBufferSize, Pos;
    unsigned char * pBuffer;
    unsigned uLit0, uLit1, uLit;
    assert( pInit->nXors == 0 && pInit->nMuxes == 0 );
 
    if ( Gia_ManCoNum(pInit) == 0 )
    {
        printf( "AIG cannot be written because it has no POs.\n" );
        return;
    }
 
    // start the output stream
    pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
    {
        fprintf( stdout, "Gia_AigerWrite(): Cannot open the output file \"%s\".\n", pFileName );
        return;
    }
 
    // create normalized AIG
    if ( !Gia_ManIsNormalized(pInit) )
    {
//        printf( "Gia_AigerWrite(): Normalizing AIG for writing.\n" );
        p = Gia_ManDupNormalize( pInit, 0 );
        Gia_ManTransferMapping( p, pInit );
        Gia_ManTransferPacking( p, pInit );
        Gia_ManTransferTiming( p, pInit );
        p->nConstrs   = pInit->nConstrs;
    }
    else
        p = pInit;
 
    // write the header "M I L O A" where M = I + L + A
    fprintf( pFile, "aig%s %u %u %u %u %u", 
        fCompact? "2" : "",
        Gia_ManCiNum(p) + Gia_ManAndNum(p), 
        Gia_ManPiNum(p),
        Gia_ManRegNum(p),
        Gia_ManConstrNum(p) ? 0 : Gia_ManPoNum(p),
        Gia_ManAndNum(p) );
    // write the extended header "B C J F"
    if ( Gia_ManConstrNum(p) )
        fprintf( pFile, " %u %u", Gia_ManPoNum(p) - Gia_ManConstrNum(p), Gia_ManConstrNum(p) );
    fprintf( pFile, "\n" ); 
 
    Gia_ManInvertConstraints( p );
    if ( !fCompact ) 
    {
        // write latch drivers
        Gia_ManForEachRi( p, pObj, i )
            fprintf( pFile, "%u\n", Gia_ObjFaninLit0p(p, pObj) );
        // write PO drivers
        Gia_ManForEachPo( p, pObj, i )
            fprintf( pFile, "%u\n", Gia_ObjFaninLit0p(p, pObj) );
    }
    else
    {
        Vec_Int_t * vLits = Gia_AigerCollectLiterals( p );
        Vec_Str_t * vBinary = Gia_AigerWriteLiterals( vLits );
        fwrite( Vec_StrArray(vBinary), 1, Vec_StrSize(vBinary), pFile );
        Vec_StrFree( vBinary );
        Vec_IntFree( vLits );
    }
    Gia_ManInvertConstraints( p );
 
    // write the nodes into the buffer
    Pos = 0;
    nBufferSize = 8 * Gia_ManAndNum(p) + 100; // skeptically assuming 3 chars per one AIG edge
    pBuffer = ABC_ALLOC( unsigned char, nBufferSize );
    Gia_ManForEachAnd( p, pObj, i )
    {
        uLit  = Abc_Var2Lit( i, 0 );
        uLit0 = Gia_ObjFaninLit0( pObj, i );
        uLit1 = Gia_ObjFaninLit1( pObj, i );
        assert( p->fGiaSimple || Gia_ManBufNum(p) || uLit0 < uLit1 );
        Pos = Gia_AigerWriteUnsignedBuffer( pBuffer, Pos, uLit  - uLit1 );
        Pos = Gia_AigerWriteUnsignedBuffer( pBuffer, Pos, uLit1 - uLit0 );
        if ( Pos > nBufferSize - 10 )
        {
            printf( "Gia_AigerWrite(): AIGER generation has failed because the allocated buffer is too small.\n" );
            fclose( pFile );
            if ( p != pInit )
                Gia_ManStop( p );
            return;
        }
    }
    assert( Pos < nBufferSize );
 
    // write the buffer
    fwrite( pBuffer, 1, Pos, pFile );
    ABC_FREE( pBuffer );
 
    // write the symbol table
    if ( p->vNamesIn && p->vNamesOut )
    {
        assert( Vec_PtrSize(p->vNamesIn)  == Gia_ManCiNum(p) );
        assert( Vec_PtrSize(p->vNamesOut) == Gia_ManCoNum(p) );
        // write PIs
        Gia_ManForEachPi( p, pObj, i )
            fprintf( pFile, "i%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesIn, i) );
        // write latches
        Gia_ManForEachRo( p, pObj, i )
            fprintf( pFile, "l%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesIn, Gia_ManPiNum(p) + i) );
        // write POs
        Gia_ManForEachPo( p, pObj, i )
            fprintf( pFile, "o%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesOut, i) );
    }
    if ( p->vNamesNode && Vec_PtrSize(p->vNamesNode) != Gia_ManObjNum(p) )
        Abc_Print( 0, "The size of the node name array does not match the number of objects. Names are not written.\n" );
    else if ( p->vNamesNode )
    {
        Gia_ManForEachAnd( p, pObj, i )
            if ( Vec_PtrEntry(p->vNamesNode, i) )
                fprintf( pFile, "n%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesNode, i) );
    }
 
    // write the comment
    if ( fWriteNewLine ) 
        fprintf( pFile, "c\n" );
    else
        fprintf( pFile, "c" );
 
    // write additional AIG
    if ( p->pAigExtra )
    {
        fprintf( pFile, "a" );
        vStrExt = Gia_AigerWriteIntoMemoryStr( p->pAigExtra );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
        if ( fVerbose ) printf( "Finished writing extension \"a\".\n" );
    }
    // write constraints
    if ( p->nConstrs )
    {
        fprintf( pFile, "c" );
        Gia_FileWriteBufferSize( pFile, 4 );
        Gia_FileWriteBufferSize( pFile, p->nConstrs );
    }
    // write timing information
    if ( p->nAnd2Delay )
    {
        fprintf( pFile, "d" );
        Gia_FileWriteBufferSize( pFile, 4 );
        Gia_FileWriteBufferSize( pFile, p->nAnd2Delay );
    }
    if ( p->pManTime )
    {
        float * pTimes;
        pTimes = Tim_ManGetArrTimes( (Tim_Man_t *)p->pManTime );
        if ( pTimes )
        {
            fprintf( pFile, "i" );
            Gia_FileWriteBufferSize( pFile, 4*Tim_ManPiNum((Tim_Man_t *)p->pManTime) );
            fwrite( pTimes, 1, 4*Tim_ManPiNum((Tim_Man_t *)p->pManTime), pFile );
            ABC_FREE( pTimes );
            if ( fVerbose ) printf( "Finished writing extension \"i\".\n" );
        }
        pTimes = Tim_ManGetReqTimes( (Tim_Man_t *)p->pManTime );
        if ( pTimes )
        {
            fprintf( pFile, "o" );
            Gia_FileWriteBufferSize( pFile, 4*Tim_ManPoNum((Tim_Man_t *)p->pManTime) );
            fwrite( pTimes, 1, 4*Tim_ManPoNum((Tim_Man_t *)p->pManTime), pFile );
            ABC_FREE( pTimes );
            if ( fVerbose ) printf( "Finished writing extension \"o\".\n" );
        }
    }
    // write equivalences
    if ( p->pReprs && p->pNexts )
    {
        extern Vec_Str_t * Gia_WriteEquivClasses( Gia_Man_t * p );
        fprintf( pFile, "e" );
        vStrExt = Gia_WriteEquivClasses( p );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
    }
    // write flop classes
    if ( p->vFlopClasses )
    {
        fprintf( pFile, "f" );
        Gia_FileWriteBufferSize( pFile, 4*Gia_ManRegNum(p) );
        assert( Vec_IntSize(p->vFlopClasses) == Gia_ManRegNum(p) );
        fwrite( Vec_IntArray(p->vFlopClasses), 1, 4*Gia_ManRegNum(p), pFile );
    }
    // write gate classes
    if ( p->vGateClasses )
    {
        fprintf( pFile, "g" );
        Gia_FileWriteBufferSize( pFile, 4*Gia_ManObjNum(p) );
        assert( Vec_IntSize(p->vGateClasses) == Gia_ManObjNum(p) );
        fwrite( Vec_IntArray(p->vGateClasses), 1, 4*Gia_ManObjNum(p), pFile );
    }
    // write hierarchy info
    if ( p->pManTime )
    {
        fprintf( pFile, "h" );
        vStrExt = Tim_ManSave( (Tim_Man_t *)p->pManTime, 1 );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
        if ( fVerbose ) printf( "Finished writing extension \"h\".\n" );
    }
    // write packing
    if ( p->vPacking )
    {
        extern Vec_Str_t * Gia_WritePacking( Vec_Int_t * vPacking );
        fprintf( pFile, "k" );
        vStrExt = Gia_WritePacking( p->vPacking );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
        if ( fVerbose ) printf( "Finished writing extension \"k\".\n" );
    }
    // write edges
    if ( p->vEdge1 )
    {
        Vec_Int_t * vPairs = Gia_ManEdgeToArray( p );
        int i;
        fprintf( pFile, "w" );
        Gia_FileWriteBufferSize( pFile, 4*(Vec_IntSize(vPairs)+1) );
        Gia_FileWriteBufferSize( pFile, Vec_IntSize(vPairs)/2 );
        for ( i = 0; i < Vec_IntSize(vPairs); i++ )
            Gia_FileWriteBufferSize( pFile, Vec_IntEntry(vPairs, i) );
        Vec_IntFree( vPairs );
    }
    // write mapping
    if ( Gia_ManHasMapping(p) )
    {
        extern Vec_Str_t * Gia_AigerWriteMapping( Gia_Man_t * p );
        extern Vec_Str_t * Gia_AigerWriteMappingSimple( Gia_Man_t * p );
        extern Vec_Str_t * Gia_AigerWriteMappingDoc( Gia_Man_t * p );
        fprintf( pFile, "m" );
        vStrExt = Gia_AigerWriteMappingDoc( p );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
        if ( fVerbose ) printf( "Finished writing extension \"m\".\n" );
    }
    // write cell mapping
    if ( Gia_ManHasCellMapping(p) )
    {
        extern Vec_Str_t * Gia_AigerWriteCellMappingDoc( Gia_Man_t * p );
        fprintf( pFile, "M" );
        vStrExt = Gia_AigerWriteCellMappingDoc( p );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
        if ( fVerbose ) printf( "Finished writing extension \"M\".\n" );
 
    }
    // write placement
    if ( p->pPlacement )
    {
        fprintf( pFile, "p" );
        Gia_FileWriteBufferSize( pFile, 4*Gia_ManObjNum(p) );
        fwrite( p->pPlacement, 1, 4*Gia_ManObjNum(p), pFile );
    }
    // write register classes
    if ( p->vRegClasses )
    {
        int i;
        fprintf( pFile, "r" );
        Gia_FileWriteBufferSize( pFile, 4*(Vec_IntSize(p->vRegClasses)+1) );
        Gia_FileWriteBufferSize( pFile, Vec_IntSize(p->vRegClasses) );
        for ( i = 0; i < Vec_IntSize(p->vRegClasses); i++ )
            Gia_FileWriteBufferSize( pFile, Vec_IntEntry(p->vRegClasses, i) );
    }
    // write register inits
    if ( p->vRegInits )
    {
        int i;
        fprintf( pFile, "s" );
        Gia_FileWriteBufferSize( pFile, 4*(Vec_IntSize(p->vRegInits)+1) );
        Gia_FileWriteBufferSize( pFile, Vec_IntSize(p->vRegInits) );
        for ( i = 0; i < Vec_IntSize(p->vRegInits); i++ )
            Gia_FileWriteBufferSize( pFile, Vec_IntEntry(p->vRegInits, i) );
    }
    // write configuration data
    if ( p->vConfigs )
    {
        fprintf( pFile, "b" );
        assert( p->pCellStr != NULL );
        Gia_FileWriteBufferSize( pFile, 4*Vec_IntSize(p->vConfigs) + strlen(p->pCellStr) + 1 );
        fwrite( p->pCellStr, 1, strlen(p->pCellStr) + 1, pFile );
//        fwrite( Vec_IntArray(p->vConfigs), 1, 4*Vec_IntSize(p->vConfigs), pFile );
        for ( i = 0; i < Vec_IntSize(p->vConfigs); i++ )
            Gia_FileWriteBufferSize( pFile, Vec_IntEntry(p->vConfigs, i) );
    }
    // write choices
    if ( Gia_ManHasChoices(p) )
    {
        int i, nPairs = 0;
        fprintf( pFile, "q" );
        for ( i = 0; i < Gia_ManObjNum(p); i++ )
            nPairs += (Gia_ObjSibl(p, i) > 0);
        Gia_FileWriteBufferSize( pFile, 4*(nPairs * 2 + 1) );
        Gia_FileWriteBufferSize( pFile, nPairs );
        for ( i = 0; i < Gia_ManObjNum(p); i++ )
            if ( Gia_ObjSibl(p, i) )
            {
                assert( i > Gia_ObjSibl(p, i) );
                Gia_FileWriteBufferSize( pFile, i );
                Gia_FileWriteBufferSize( pFile, Gia_ObjSibl(p, i) );
            }
        if ( fVerbose ) printf( "Finished writing extension \"q\".\n" );
    }
    // write switching activity
    if ( p->pSwitching )
    {
        fprintf( pFile, "u" );
        Gia_FileWriteBufferSize( pFile, Gia_ManObjNum(p) );
        fwrite( p->pSwitching, 1, Gia_ManObjNum(p), pFile );
    }
/*
    // write timing information
    if ( p->pManTime )
    {
        fprintf( pFile, "t" );
        vStrExt = Tim_ManSave( (Tim_Man_t *)p->pManTime, 0 );
        Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
        fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
        Vec_StrFree( vStrExt );
    }
*/
    // write object classes
    if ( p->vObjClasses )
    {
        fprintf( pFile, "v" );
        Gia_FileWriteBufferSize( pFile, 4*Gia_ManObjNum(p) );
        assert( Vec_IntSize(p->vObjClasses) == Gia_ManObjNum(p) );
        fwrite( Vec_IntArray(p->vObjClasses), 1, 4*Gia_ManObjNum(p), pFile );
    }
    // write name
    if ( p->pName )
    {
        fprintf( pFile, "n" );
        Gia_FileWriteBufferSize( pFile, strlen(p->pName)+1 );
        fwrite( p->pName, 1, strlen(p->pName), pFile );
        fprintf( pFile, "%c", '\0' );
    }
    // write comments
    if ( fWriteNewLine )
        fprintf( pFile, "c\n" );
    if ( !fSkipComment ) {
        fprintf( pFile, "\nThis file was produced by the GIA package in ABC on %s\n", Gia_TimeStamp() );
        fprintf( pFile, "For information about AIGER format, refer to %s\n", "http://fmv.jku.at/aiger" );
    }
    fclose( pFile );
    if ( p != pInit )
    {
        Gia_ManTransferTiming( pInit, p );
        Gia_ManStop( p );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_AigerWriteSimple()

void Gia_AigerWriteSimple	(	Gia_Man_t *	pInit,
		char *	pFileName )

extern

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

Synopsis [Writes the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 1629 of file giaAiger.c.

{
    FILE * pFile;
    Vec_Str_t * vStr;
    if ( Gia_ManPoNum(pInit) == 0 )
    {
        printf( "Gia_AigerWriteSimple(): AIG cannot be written because it has no POs.\n" );
        return;
    }
    // start the output stream
    pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
    {
        fprintf( stdout, "Gia_AigerWriteSimple(): Cannot open the output file \"%s\".\n", pFileName );
        return;
    }
    // write the buffer
    vStr = Gia_AigerWriteIntoMemoryStr( pInit );
    fwrite( Vec_StrArray(vStr), 1, Vec_StrSize(vStr), pFile );
    Vec_StrFree( vStr );
    fclose( pFile );
}

Here is the call graph for this function:

◆ Gia_DumpAiger()

void Gia_DumpAiger	(	Gia_Man_t *	p,
		char *	pFilePrefix,
		int	iFileNum,
		int	nFileNumDigits )

extern

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

Synopsis [Writes the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 1611 of file giaAiger.c.

{
    char Buffer[100];
    sprintf( Buffer, "%s%0*d.aig", pFilePrefix, nFileNumDigits, iFileNum );
    Gia_AigerWrite( p, Buffer, 0, 0, 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_FileNameGenericAppend()

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

extern

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_FileSize()

int Gia_FileSize ( char * pFileName )

extern

FUNCTION DECLARATIONS ///.

Definition at line 64 of file giaAiger.c.

{
    FILE * pFile;
    int nFileSize;
    pFile = fopen( pFileName, "r" );
    if ( pFile == NULL )
    {
        printf( "Gia_FileSize(): The file is unavailable (absent or open).\n" );
        return 0;
    }
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile ); 
    fclose( pFile );
    return nFileSize;
}

Here is the caller graph for this function:

◆ Gia_GetFakeNames()

Vec_Ptr_t * Gia_GetFakeNames	(	int	nNames,
		int	fCaps )

extern

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_LutComputeTruth6()

word Gia_LutComputeTruth6	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Wrd_t *	vTruths )

extern

Definition at line 249 of file giaTruth.c.

{
    int k, iFan;
    assert( Gia_ObjIsLut(p, iObj) );
    Gia_ManIncrementTravId( p );
    Gia_LutForEachFanin( p, iObj, iFan, k )
    {
        Vec_WrdWriteEntry( vTruths, iFan, s_Truths6[k] );
        Gia_ObjSetTravIdCurrentId( p, iFan );
    }
    return Gia_LutComputeTruth6_rec( p, iObj, vTruths );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_Man2SupportAnd()

int Gia_Man2SupportAnd	(	Gia_Man2Min_t *	p,
		int	iLit0,
		int	iLit1 )

extern

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

Synopsis [Takes a literal and returns a support-minized literal.]

Description []

SideEffects []

SeeAlso []

Definition at line 815 of file giaSupp.c.

{
    p->nCalls++;
    //return Gia_ManHashAnd( p->pGia, iLit0, iLit1 );
    p->iLits[0] = iLit0;
    p->iLits[1] = iLit1;
    if ( iLit0 < 2 || iLit1 < 2 || Abc_Lit2Var(iLit0) == Abc_Lit2Var(iLit1) || Gia_ManHashLookupInt(p->pGia, iLit0, iLit1) || 
         !Gia_Min2ManGatherSupp(p) || !Gia_Min2ManSimulate(p) || !Gia_Min2ManSolve(p) )
        return Gia_ManHashAnd( p->pGia, iLit0, iLit1 );
    //printf( "%d %d\n", iLit0, iLit1 );
    p->nSatUnsat++;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_Man2SuppStart()

Gia_Man2Min_t * Gia_Man2SuppStart ( Gia_Man_t * pGia )

extern

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

Synopsis [Create/delete the data representation manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 375 of file giaSupp.c.

{
    Gia_Man2Min_t * p;
    p = ABC_CALLOC( Gia_Man2Min_t, 1 );
    p->pGia      = pGia;
    p->vCis[0]   = Vec_IntAlloc( 512 );
    p->vCis[1]   = Vec_IntAlloc( 512 );
    p->vObjs[0]  = Vec_IntAlloc( 512 );
    p->vObjs[1]  = Vec_IntAlloc( 512 );
    // SAT solving
    p->pSat      = satoko_create();
    p->vSims     = Vec_WrdAlloc( 1000 );
    p->vFrontier = Vec_PtrAlloc( 1000 );
    p->vFanins   = Vec_PtrAlloc( 100 );
    p->vSatVars  = Vec_IntAlloc( 100 );
    p->iPattern  = 1;
    satoko_options(p->pSat)->learnt_ratio = 0; // prevent garbage collection
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_Man2SuppStop()

void Gia_Man2SuppStop ( Gia_Man2Min_t * p )

extern

Definition at line 394 of file giaSupp.c.

{
//    printf( "Total calls = %8d.  Supps = %6d.  Sims = %6d.   SAT = %6d.  UNSAT = %6d.\n", 
//        p->nCalls, p->nSupps, p->nSims, p->nSatSat, p->nSatUnsat );
    Vec_IntFreeP( &p->vCis[0] );
    Vec_IntFreeP( &p->vCis[1] );
    Vec_IntFreeP( &p->vObjs[0] );
    Vec_IntFreeP( &p->vObjs[1] );
    Gia_ManCleanMark01( p->pGia );
    satoko_destroy( p->pSat );
    Vec_WrdFreeP( &p->vSims );
    Vec_PtrFreeP( &p->vFrontier );
    Vec_PtrFreeP( &p->vFanins );
    Vec_IntFreeP( &p->vSatVars );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManAigSyn2()

Gia_Man_t * Gia_ManAigSyn2	(	Gia_Man_t *	pInit,
		int	fOldAlgo,
		int	fCoarsen,
		int	fCutMin,
		int	nRelaxRatio,
		int	fDelayMin,
		int	fVerbose,
		int	fVeryVerbose )

extern

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

Synopsis [Synthesis script.]

Description []

SideEffects []

SeeAlso []

Definition at line 69 of file giaScript.c.

{
    Gia_Man_t * p, * pNew, * pTemp;
    Jf_Par_t Pars, * pPars = &Pars;
    if ( fOldAlgo )
    {
        Jf_ManSetDefaultPars( pPars );
        pPars->fCutMin     = fCutMin;
    }
    else
    {
        Lf_ManSetDefaultPars( pPars );
        pPars->fCutMin     = fCutMin;
        pPars->fCoarsen    = fCoarsen;
        pPars->nRelaxRatio = nRelaxRatio;
        pPars->nAreaTuner  = 1;
        pPars->nCutNum     = 4;
    }
    if ( fVerbose )  Gia_ManPrintStats( pInit, NULL );
    p = Gia_ManDup( pInit );
    Gia_ManTransferTiming( p, pInit );
    if ( Gia_ManAndNum(p) == 0 )
    {
        pNew = Gia_ManDup(p);
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p );
        return pNew;
    }
    // delay optimization
    if ( fDelayMin && p->pManTime == NULL )
    {
        int Area0, Area1, Delay0, Delay1;
        int fCutMin = pPars->fCutMin;
        int fCoarsen = pPars->fCoarsen;
        int nRelaxRatio = pPars->nRelaxRatio;
        pPars->fCutMin = 0;
        pPars->fCoarsen = 0;
        pPars->nRelaxRatio = 0;
        // perform mapping
        if ( fOldAlgo )
            Jf_ManPerformMapping( p, pPars );
        else
            Lf_ManPerformMapping( p, pPars );
        Area0  = (int)pPars->Area;
        Delay0 = (int)pPars->Delay;
        // perform balancing
        pNew = Gia_ManPerformDsdBalance( p, 6, 4, 0, 0 );
        // perform mapping again
        if ( fOldAlgo )
            Jf_ManPerformMapping( pNew, pPars );
        else
            Lf_ManPerformMapping( pNew, pPars );
        Area1  = (int)pPars->Area;
        Delay1 = (int)pPars->Delay;
        // choose the best result
        if ( Delay1 < Delay0 - 1 || (Delay1 == Delay0 + 1 && 100.0 * (Area1 - Area0) / Area1 < 3.0) )
        {
            Gia_ManStop( p );
            p = pNew;
        }
        else
        {
            Gia_ManStop( pNew );
            Vec_IntFreeP( &p->vMapping );
        }
        // reset params
        pPars->fCutMin = fCutMin;
        pPars->fCoarsen = fCoarsen;
        pPars->nRelaxRatio = nRelaxRatio;
    }
    // perform balancing
    pNew = Gia_ManAreaBalance( p, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( p );
    // perform mapping
    if ( fOldAlgo )
        pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
    else
        pNew = Lf_ManPerformMapping( pTemp = pNew, pPars );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    if ( pTemp != pNew )
        Gia_ManStop( pTemp );
    // perform balancing
    pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManAigSyn3()

Gia_Man_t * Gia_ManAigSyn3	(	Gia_Man_t *	p,
		int	fVerbose,
		int	fVeryVerbose )

extern

Definition at line 157 of file giaScript.c.

{
    Gia_Man_t * pNew, * pTemp;
    Jf_Par_t Pars, * pPars = &Pars;
    Jf_ManSetDefaultPars( pPars );
    pPars->nRelaxRatio = 40;
    if ( fVerbose )     Gia_ManPrintStats( p, NULL );
    if ( Gia_ManAndNum(p) == 0 )
    {
        pNew = Gia_ManDup(p);
        Gia_ManTransferTiming( pNew, p );
        //Gia_ManStop( p );
        return pNew;
    }
    // perform balancing
    pNew = Gia_ManAreaBalance( p, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    // perform mapping
    pPars->nLutSize = 6;
    pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
//    Gia_ManStop( pTemp );
    // perform balancing
    pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
    // perform mapping
    pPars->nLutSize = 4;
    pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
//    Gia_ManStop( pTemp );
    // perform balancing
    pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManAigSyn4()

Gia_Man_t * Gia_ManAigSyn4	(	Gia_Man_t *	p,
		int	fVerbose,
		int	fVeryVerbose )

extern

Definition at line 194 of file giaScript.c.

{
    Gia_Man_t * pNew, * pTemp;
    Jf_Par_t Pars, * pPars = &Pars;
    Jf_ManSetDefaultPars( pPars );
    pPars->nRelaxRatio = 40;
    if ( fVerbose )     Gia_ManPrintStats( p, NULL );
    if ( Gia_ManAndNum(p) == 0 )
    {
        pNew = Gia_ManDup(p);
        Gia_ManTransferTiming( pNew, p );
        //Gia_ManStop( p );
        return pNew;
    }
//Gia_ManAigPrintPiLevels( p );
    // perform balancing
    pNew = Gia_ManAreaBalance( p, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    // perform mapping
    pPars->nLutSize = 7;
    pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
//    Gia_ManStop( pTemp );
    // perform extraction
    pNew = Gia_ManPerformFx( pTemp = pNew, ABC_INFINITY, 0, 0, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
    // perform balancing
    pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
    // perform mapping
    pPars->nLutSize = 5;
    pNew = Jf_ManPerformMapping( pTemp = pNew, pPars );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
//    Gia_ManStop( pTemp );
    // perform extraction
    pNew = Gia_ManPerformFx( pTemp = pNew, ABC_INFINITY, 0, 0, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
    // perform balancing
    pNew = Gia_ManAreaBalance( pTemp = pNew, 0, ABC_INFINITY, fVeryVerbose, 0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    Gia_ManStop( pTemp );
//Gia_ManAigPrintPiLevels( pNew );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManAreaBalance()

Gia_Man_t * Gia_ManAreaBalance	(	Gia_Man_t *	p,
		int	fSimpleAnd,
		int	nNewNodesMax,
		int	fVerbose,
		int	fVeryVerbose )

extern

Definition at line 1047 of file giaBalAig.c.

{
    Gia_Man_t * pNew0, * pNew, * pNew1, * pNew2;
    Vec_Int_t * vCiLevels;
    // set arrival times for the input of the new AIG
    if ( p->vCiArrs )
    {
        int i, Id, And2Delay = p->And2Delay ? p->And2Delay : 1;
        Vec_IntFreeP( &p->vLevels );
        p->vLevels = Vec_IntStart( Gia_ManObjNum(p) );
        Gia_ManForEachCiId( p, Id, i )
            Vec_IntWriteEntry( p->vLevels, Id, Vec_IntEntry(p->vCiArrs, i)/And2Delay );
    }
    else if ( p->vInArrs )
    {
        int i, Id, And2Delay = p->And2Delay ? p->And2Delay : 1;
        Gia_ManForEachCiId( p, Id, i )
            Vec_IntWriteEntry( p->vLevels, Id, (int)(Vec_FltEntry(p->vInArrs, i)/And2Delay) );
    }
    // determine CI levels
    if ( p->pManTime && p->vLevels == NULL )
        Gia_ManLevelWithBoxes( p );
    vCiLevels = Gia_ManGetCiLevels( p );
    // get the starting manager
    pNew0 = Gia_ManHasMapping(p) ? (Gia_Man_t *)Dsm_ManDeriveGia(p, 0) : Gia_ManDup(p);
    Gia_ManTransferTiming( pNew0, p );
    if ( fVerbose )     Gia_ManPrintStats( pNew0, NULL );
    // derive internal manager
    pNew = fSimpleAnd ? Gia_ManDup( pNew0 ) : Gia_ManDupMuxes( pNew0, 2 );
    Gia_ManTransferTiming( pNew, pNew0 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    if ( pNew0 != p ) Gia_ManStop( pNew0 );
    // perform the operation
    pNew1 = Dam_ManAreaBalanceInt( pNew, vCiLevels, nNewNodesMax, fVerbose, fVeryVerbose );
    Gia_ManTransferTiming( pNew1, pNew );
    if ( fVerbose )     Gia_ManPrintStats( pNew1, NULL );
    Gia_ManStop( pNew );
    Vec_IntFreeP( &vCiLevels );
    // derive the final result
    pNew2 = Gia_ManDupNoMuxes( pNew1, 0 );
    Gia_ManTransferTiming( pNew2, pNew1 );
    if ( fVerbose )     Gia_ManPrintStats( pNew2, NULL );
    Gia_ManStop( pNew1 );
    // normalize if needed
    if ( !Gia_ManIsNormalized(pNew2) )
    {
        pNew2 = Gia_ManDupNormalize( pNew1 = pNew2, 0 );
        Gia_ManTransferTiming( pNew2, pNew1 );
        Gia_ManStop( pNew1 );
    }
    //Gia_ManTransferTiming( pNew2, p );
    return pNew2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManArray2Sim()

Vec_Ptr_t * Gia_ManArray2Sim ( Vec_Wec_t * vRes )

extern

Definition at line 2596 of file giaSimBase.c.

{
    Vec_Ptr_t * vSims = Vec_PtrAlloc( Vec_WecSize(vRes) );
    Vec_Int_t * vLevel; int i;
    Vec_WecForEachLevel( vRes, vLevel, i )
        Vec_PtrPush( vSims, Gia_ManArray2SimOne(vLevel) );
    return vSims;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManArray2SimOne()

Vec_Wrd_t * Gia_ManArray2SimOne ( Vec_Int_t * vRes )

extern

Definition at line 2579 of file giaSimBase.c.

{
    int i, iLit, nWords = Vec_IntEntryLast(vRes);
    Vec_Wrd_t * vSimsPi = Vec_WrdStart( 2*nWords );
    word * pInfo = Vec_WrdArray(vSimsPi);
    word * pCare = pInfo + nWords;
    Vec_IntPop( vRes );
    Vec_IntForEachEntry( vRes, iLit, i )
    {
        Abc_TtXorBit( pCare, Abc_Lit2Var(iLit) );
        if ( Abc_LitIsCompl(iLit) )
            Abc_TtXorBit( pInfo, Abc_Lit2Var(iLit) );
    }
    Vec_IntPush( vRes, nWords );
    Vec_WrdShrink( vSimsPi, Vec_WrdSize(vSimsPi)/2 );
    return vSimsPi;
}

Here is the caller graph for this function:

◆ Gia_ManBalance()

Gia_Man_t * Gia_ManBalance	(	Gia_Man_t *	p,
		int	fSimpleAnd,
		int	fStrict,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 441 of file giaBalAig.c.

{
    Gia_Man_t * pNew, * pNew1, * pNew2;
    if ( fVerbose )      Gia_ManPrintStats( p, NULL );
    pNew = fSimpleAnd ? Gia_ManDup( p ) : Gia_ManDupMuxes( p, 2 );
    Gia_ManTransferTiming( pNew, p );
    if ( fVerbose )      Gia_ManPrintStats( pNew, NULL );
    pNew1 = Gia_ManBalanceInt( pNew, fStrict );
    Gia_ManTransferTiming( pNew1, pNew );
    if ( fVerbose )      Gia_ManPrintStats( pNew1, NULL );
    Gia_ManStop( pNew );
    pNew2 = Gia_ManDupNoMuxes( pNew1, 0 );
    Gia_ManTransferTiming( pNew2, pNew1 );
    if ( fVerbose )      Gia_ManPrintStats( pNew2, NULL );
    Gia_ManStop( pNew1 );
    return pNew2;
}

Here is the call graph for this function:

◆ Gia_ManBlackBoxNum()

int Gia_ManBlackBoxNum ( Gia_Man_t * p )

extern

Definition at line 62 of file giaTim.c.

{
    return Tim_ManBlackBoxNum((Tim_Man_t *)p->pManTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManBoxCiNum()

int Gia_ManBoxCiNum ( Gia_Man_t * p )

extern

Definition at line 66 of file giaTim.c.

{
    return p->pManTime ? Gia_ManCiNum(p) - Tim_ManPiNum((Tim_Man_t *)p->pManTime) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManBoxCoNum()

int Gia_ManBoxCoNum ( Gia_Man_t * p )

extern

Definition at line 70 of file giaTim.c.

{
    return p->pManTime ? Gia_ManCoNum(p) - Tim_ManPoNum((Tim_Man_t *)p->pManTime) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManBoxNum()

int Gia_ManBoxNum ( Gia_Man_t * p )

extern

DECLARATIONS ///.

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

FileName [giaTim.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Procedures with hierarchy/timing manager.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Returns the number of boxes in the AIG with boxes.]

Description []

SideEffects []

SeeAlso []

Definition at line 50 of file giaTim.c.

{
    return p->pManTime ? Tim_ManBoxNum((Tim_Man_t *)p->pManTime) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManBuiltInSimAddPat()

int Gia_ManBuiltInSimAddPat	(	Gia_Man_t *	p,
		Vec_Int_t *	vPat )

extern

Definition at line 963 of file giaSim.c.

{
    int Period = 0xF;
    int fOverflow = p->iPatsPi == 64 * p->nSimWords && p->nSimWords == p->nSimWordsMax;
    int k, iLit, iPat = Gia_ManBuiltInSimPack( p, vPat );
    if ( iPat == -1 )
    {
        if ( fOverflow )
        {
            if ( (p->iPastPiMax & Period) == 0 )
                Gia_ManBuiltInSimResimulate( p );
            iPat = p->iPastPiMax;
            //if ( p->iPastPiMax == 64 * p->nSimWordsMax - 1 )
            //    printf( "Completed the cycle.\n" );
            p->iPastPiMax = p->iPastPiMax == 64 * p->nSimWordsMax - 1 ? 0 : p->iPastPiMax + 1;
        }
        else
        {
            if ( p->iPatsPi && (p->iPatsPi & Period) == 0 )
                Gia_ManBuiltInSimResimulate( p );
            if ( p->iPatsPi == 64 * p->nSimWords )
            {
                Vec_Wrd_t * vTemp = Vec_WrdAlloc( 2 * Vec_WrdSize(p->vSims) ); 
                word Data; int w, Count = 0, iObj = 0;
                Vec_WrdForEachEntry( p->vSims, Data, w )
                {
                    Vec_WrdPush( vTemp, Data );
                    if ( ++Count == p->nSimWords )
                    {
                        Gia_Obj_t * pObj = Gia_ManObj(p, iObj++);
                        if ( Gia_ObjIsCi(pObj) )
                            Vec_WrdPush( vTemp, Gia_ManRandomW(0) ); // Vec_WrdPush( vTemp, 0 );
                        else if ( Gia_ObjIsAnd(pObj) )
                            Vec_WrdPush( vTemp, pObj->fPhase ? ~(word)0 : 0 );
                        else
                            Vec_WrdPush( vTemp, 0 );
                        Count = 0;
                    }
                }
                assert( iObj == Gia_ManObjNum(p) );
                Vec_WrdFree( p->vSims );
                p->vSims = vTemp;
 
                vTemp = Vec_WrdAlloc( 2 * Vec_WrdSize(p->vSimsPi) ); 
                Count = 0;
                Vec_WrdForEachEntry( p->vSimsPi, Data, w )
                {
                    Vec_WrdPush( vTemp, Data );
                    if ( ++Count == p->nSimWords )
                    {
                        Vec_WrdPush( vTemp, 0 );
                        Count = 0;
                    }
                }
                Vec_WrdFree( p->vSimsPi );
                p->vSimsPi = vTemp;
 
                // update the word count
                p->nSimWords++;
                assert( Vec_WrdSize(p->vSims)   == p->nSimWords * Gia_ManObjNum(p) );
                assert( Vec_WrdSize(p->vSimsPi) == p->nSimWords * Gia_ManCiNum(p)  );
                //printf( "Resizing to %d words.\n", p->nSimWords );
            }
            iPat = p->iPatsPi++;
        }
    }
    assert( iPat >= 0 && iPat < p->iPatsPi );
    // add literals 
    if ( fOverflow )
    {
        int iVar;
        Vec_IntForEachEntry( &p->vSuppVars, iVar, k )
            if ( Abc_TtGetBit(Gia_ManBuiltInDataPi(p, iVar), iPat) )
                 Abc_TtXorBit(Gia_ManBuiltInDataPi(p, iVar), iPat);
        Vec_IntForEachEntry( vPat, iLit, k )
        {
            if ( Abc_TtGetBit(Gia_ManBuiltInData(p, 1+Abc_Lit2Var(iLit)), iPat) == Abc_LitIsCompl(iLit) )
            Abc_TtXorBit(Gia_ManBuiltInData(p, 1+Abc_Lit2Var(iLit)), iPat);
            Abc_TtXorBit(Gia_ManBuiltInDataPi(p, Abc_Lit2Var(iLit)), iPat);
        }
    }
    else
    {
        Vec_IntForEachEntry( vPat, iLit, k )
        {
            if ( Abc_TtGetBit(Gia_ManBuiltInDataPi(p, Abc_Lit2Var(iLit)), iPat) )
                assert( Abc_TtGetBit(Gia_ManBuiltInData(p, 1+Abc_Lit2Var(iLit)), iPat) != Abc_LitIsCompl(iLit) );
            else 
            {
                if ( Abc_TtGetBit(Gia_ManBuiltInData(p, 1+Abc_Lit2Var(iLit)), iPat) == Abc_LitIsCompl(iLit) )
                Abc_TtXorBit(Gia_ManBuiltInData(p, 1+Abc_Lit2Var(iLit)), iPat);
                Abc_TtXorBit(Gia_ManBuiltInDataPi(p, Abc_Lit2Var(iLit)), iPat);
            }
        }
    }
    return 1;
}

Here is the call graph for this function:

◆ Gia_ManBuiltInSimCheckEqual()

int Gia_ManBuiltInSimCheckEqual	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 902 of file giaSim.c.

{
    word * pInfo0 = Gia_ManBuiltInData( p, Abc_Lit2Var(iLit0) );
    word * pInfo1 = Gia_ManBuiltInData( p, Abc_Lit2Var(iLit1) ); int w;
    assert( p->fBuiltInSim || p->fIncrSim );
 
//    printf( "%d %d\n", Abc_LitIsCompl(iLit0), Abc_LitIsCompl(iLit1) );
//    Extra_PrintBinary( stdout, pInfo0, 64*p->nSimWords ); printf( "\n" );
//    Extra_PrintBinary( stdout, pInfo1, 64*p->nSimWords ); printf( "\n" );
//    printf( "\n" );
 
    if ( Abc_LitIsCompl(iLit0) )
    {
        if (  Abc_LitIsCompl(iLit1) )
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( ~pInfo0[w] != ~pInfo1[w] )
                    return 0;
        }
        else 
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( ~pInfo0[w] != pInfo1[w] )
                    return 0;
        }
    }
    else 
    {
        if (  Abc_LitIsCompl(iLit1) )
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( pInfo0[w] != ~pInfo1[w] )
                    return 0;
        }
        else 
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( pInfo0[w] != pInfo1[w] )
                    return 0;
        }
    }
    return 1;
}

Here is the caller graph for this function:

◆ Gia_ManBuiltInSimCheckOver()

int Gia_ManBuiltInSimCheckOver	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 859 of file giaSim.c.

{
    word * pInfo0 = Gia_ManBuiltInData( p, Abc_Lit2Var(iLit0) );
    word * pInfo1 = Gia_ManBuiltInData( p, Abc_Lit2Var(iLit1) ); int w;
    assert( p->fBuiltInSim || p->fIncrSim );
 
//    printf( "%d %d\n", Abc_LitIsCompl(iLit0), Abc_LitIsCompl(iLit1) );
//    Extra_PrintBinary( stdout, pInfo0, 64*p->nSimWords ); printf( "\n" );
//    Extra_PrintBinary( stdout, pInfo1, 64*p->nSimWords ); printf( "\n" );
//    printf( "\n" );
 
    if ( Abc_LitIsCompl(iLit0) )
    {
        if (  Abc_LitIsCompl(iLit1) )
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( ~pInfo0[w] & ~pInfo1[w] )
                    return 1;
        }
        else 
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( ~pInfo0[w] & pInfo1[w] )
                    return 1;
        }
    }
    else 
    {
        if (  Abc_LitIsCompl(iLit1) )
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( pInfo0[w] & ~pInfo1[w] )
                    return 1;
        }
        else 
        {
            for ( w = 0; w < p->nSimWords; w++ )
                if ( pInfo0[w] & pInfo1[w] )
                    return 1;
        }
    }
    return 0;
}

Here is the caller graph for this function:

◆ Gia_ManBuiltInSimPerform()

void Gia_ManBuiltInSimPerform	(	Gia_Man_t *	p,
		int	iObj )

extern

Definition at line 824 of file giaSim.c.

{
    int w;
    for ( w = 0; w < p->nSimWords; w++ )
        Vec_WrdPush( p->vSims, 0 );
    Gia_ManBuiltInSimPerformInt( p, iObj );
}

Here is the call graph for this function:

◆ Gia_ManBuiltInSimResimulate()

void Gia_ManBuiltInSimResimulate ( Gia_Man_t * p )

extern

Definition at line 852 of file giaSim.c.

{
    Gia_Obj_t * pObj;  int iObj;
    Gia_ManForEachAnd( p, pObj, iObj )
        Gia_ManBuiltInSimPerformInt( p, iObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManBuiltInSimResimulateCone()

void Gia_ManBuiltInSimResimulateCone	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 846 of file giaSim.c.

{
    Gia_ManIncrementTravId( p );
    Gia_ManBuiltInSimResimulateCone_rec( p, Abc_Lit2Var(iLit0) );
    Gia_ManBuiltInSimResimulateCone_rec( p, Abc_Lit2Var(iLit1) );
}

Here is the call graph for this function:

◆ Gia_ManBuiltInSimStart()

void Gia_ManBuiltInSimStart	(	Gia_Man_t *	p,
		int	nWords,
		int	nObjs )

extern

Definition at line 776 of file giaSim.c.

{
    int i, k;
    assert( !p->fBuiltInSim );
    assert( Gia_ManAndNum(p) == 0 );
    p->fBuiltInSim = 1;
    p->iPatsPi = 0;
    p->iPastPiMax = 0;
    p->nSimWords = nWords;
    p->nSimWordsMax = 8;
    Gia_ManRandomW( 1 );
    // init PI care info
    p->vSimsPi = Vec_WrdAlloc( p->nSimWords * Gia_ManCiNum(p) );
    Vec_WrdFill( p->vSimsPi, p->nSimWords * Gia_ManCiNum(p), 0 );
    // init object sim info
    p->vSims = Vec_WrdAlloc( p->nSimWords * nObjs );
    Vec_WrdFill( p->vSims, p->nSimWords, 0 );
    for ( i = 0; i < Gia_ManCiNum(p); i++ )
        for ( k = 0; k < p->nSimWords; k++ )
            Vec_WrdPush( p->vSims, Gia_ManRandomW(0) );
}

Here is the call graph for this function:

◆ Gia_ManCexExtendToIncludeAllObjects()

Abc_Cex_t * Gia_ManCexExtendToIncludeAllObjects	(	Gia_Man_t *	p,
		Abc_Cex_t *	pCex )

extern

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

Synopsis [Returns CEX containing all object valuess for each timeframe.]

Description []

SideEffects []

SeeAlso []

Definition at line 353 of file giaCex.c.

{
    Abc_Cex_t * pNew;
    Gia_Obj_t * pObj, * pObjRo, * pObjRi;
    int i, k, iBit = 0;
    assert( pCex->nRegs > 0 );
    // start the counter-example
    pNew = Abc_CexAlloc( 0, Gia_ManObjNum(p), pCex->iFrame + 1 );
    pNew->iFrame = pCex->iFrame;
    pNew->iPo    = pCex->iPo;
    // set const0
    Gia_ManConst0(p)->fMark0 = 0;
    // set init state
    Gia_ManForEachRi( p, pObjRi, k )
        pObjRi->fMark0 = Abc_InfoHasBit(pCex->pData, iBit++);
    assert( iBit == pCex->nRegs );
    for ( i = 0; i <= pCex->iFrame; i++ )
    {
        Gia_ManForEachPi( p, pObj, k )
            pObj->fMark0 = Abc_InfoHasBit(pCex->pData, iBit++);
        Gia_ManForEachRiRo( p, pObjRi, pObjRo, k )
            pObjRo->fMark0 = pObjRi->fMark0;
        Gia_ManForEachObj( p, pObj, k )
            if ( pObj->fMark0 )
                Abc_InfoSetBit( pNew->pData, pNew->nPis * i + k );
        Gia_ManForEachAnd( p, pObj, k )
            pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
        Gia_ManForEachCo( p, pObj, k )
            pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj);
    }
    assert( iBit == pCex->nBits );
    assert( Gia_ManPo(p, pCex->iPo)->fMark0 == 1 );
    Gia_ManCleanMark0(p);
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManCexExtendToIncludeCurrentStates()

Abc_Cex_t * Gia_ManCexExtendToIncludeCurrentStates	(	Gia_Man_t *	p,
		Abc_Cex_t *	pCex )

extern

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

Synopsis [Returns CEX containing PI+CS values for each timeframe.]

Description []

SideEffects []

SeeAlso []

Definition at line 306 of file giaCex.c.

{
    Abc_Cex_t * pNew;
    Gia_Obj_t * pObj, * pObjRo, * pObjRi;
    int i, k, iBit = 0;
    assert( pCex->nRegs > 0 );
    // start the counter-example
    pNew = Abc_CexAlloc( 0, Gia_ManCiNum(p), pCex->iFrame + 1 );
    pNew->iFrame = pCex->iFrame;
    pNew->iPo    = pCex->iPo;
    // set const0
    Gia_ManConst0(p)->fMark0 = 0;
    // set init state
    Gia_ManForEachRi( p, pObjRi, k )
        pObjRi->fMark0 = Abc_InfoHasBit(pCex->pData, iBit++);
    assert( iBit == pCex->nRegs );
    for ( i = 0; i <= pCex->iFrame; i++ )
    {
        Gia_ManForEachPi( p, pObj, k )
            pObj->fMark0 = Abc_InfoHasBit(pCex->pData, iBit++);
        Gia_ManForEachRiRo( p, pObjRi, pObjRo, k )
            pObjRo->fMark0 = pObjRi->fMark0;
        Gia_ManForEachCi( p, pObj, k )
            if ( pObj->fMark0 )
                Abc_InfoSetBit( pNew->pData, pNew->nPis * i + k );
        Gia_ManForEachAnd( p, pObj, k )
            pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
        Gia_ManForEachCo( p, pObj, k )
            pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj);
    }
    assert( iBit == pCex->nBits );
    assert( Gia_ManPo(p, pCex->iPo)->fMark0 == 1 );
    Gia_ManCleanMark0(p);
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManCheckCoPhase()

int Gia_ManCheckCoPhase ( Gia_Man_t * p )

extern

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_ManCheckIntegrityWithBoxes()

void Gia_ManCheckIntegrityWithBoxes ( Gia_Man_t * p )

extern

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

Synopsis [Checks integriting of complex flops and carry-chains.]

Description []

SideEffects []

SeeAlso []

Definition at line 441 of file giaSweep.c.

{
    Gia_Obj_t * pObj;
    Vec_Int_t * vCarryOuts;
    int i, nCountReg = 0, nCountCarry = 0;
    if ( p->pManTime == NULL )
        return;
    ABC_FREE( p->pRefs );
    Gia_ManCreateRefs( p );
    for ( i = Gia_ManPoNum(p) - Gia_ManRegBoxNum(p); i < Gia_ManPoNum(p); i++ )
    {
        pObj = Gia_ObjFanin0( Gia_ManPo(p, i) );
        assert( Gia_ObjIsCi(pObj) );
        if ( Gia_ObjRefNum(p, pObj) > 1 )
            nCountReg++;
    }
    vCarryOuts = Gia_ManComputeCarryOuts( p );
    Gia_ManForEachObjVec( vCarryOuts, p, pObj, i )
        if ( Gia_ObjRefNum(p, pObj) > 1 )
            nCountCarry++;
    Vec_IntFree( vCarryOuts );
    if ( nCountReg || nCountCarry )
        printf( "Warning: AIG with boxes has internal fanout in %d complex flops and %d carries.\n", nCountReg, nCountCarry );
    ABC_FREE( p->pRefs );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCheckMark0()

void Gia_ManCheckMark0 ( Gia_Man_t * p )

extern

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 )

extern

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_ManCheckSuppOverlap()

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

extern

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_ManCheckTopoOrder()

int Gia_ManCheckTopoOrder ( Gia_Man_t * p )

extern

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

Synopsis [Returns 0 if AIG is not in the required topo order.]

Description [AIG should be in such an order that the representative is always traversed before the node.]

SideEffects []

SeeAlso []

Definition at line 236 of file giaEquiv.c.

{
    Gia_Obj_t * pObj;
    int i, RetValue = 1;
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = 0;
    Gia_ManForEachCo( p, pObj, i )
        RetValue &= Gia_ManCheckTopoOrder_rec( p, Gia_ObjFanin0(pObj) );
    return RetValue;
}

Here is the call graph for this function:

◆ Gia_ManChoiceMiter()

Gia_Man_t * Gia_ManChoiceMiter ( Vec_Ptr_t * vGias )

extern

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

Synopsis [Derives the miter of several AIGs for choice computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 3763 of file giaDup.c.

{
    Gia_Man_t * pNew, * pGia, * pGia0;
    int i, k, iNode, nNodes;
    // make sure they have equal parameters
    assert( Vec_PtrSize(vGias) > 0 );
    pGia0 = (Gia_Man_t *)Vec_PtrEntry( vGias, 0 );
    Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
    {
        assert( Gia_ManCiNum(pGia)  == Gia_ManCiNum(pGia0) );
        assert( Gia_ManCoNum(pGia)  == Gia_ManCoNum(pGia0) );
        assert( Gia_ManRegNum(pGia) == Gia_ManRegNum(pGia0) );
        Gia_ManFillValue( pGia );
        Gia_ManConst0(pGia)->Value = 0;
    }
    // start the new manager
    pNew = Gia_ManStart( Vec_PtrSize(vGias) * Gia_ManObjNum(pGia0) );
    pNew->pName = Abc_UtilStrsav( pGia0->pName );
    pNew->pSpec = Abc_UtilStrsav( pGia0->pSpec );
    // create new CIs and assign them to the old manager CIs
    for ( k = 0; k < Gia_ManCiNum(pGia0); k++ )
    {
        iNode = Gia_ManAppendCi(pNew);
        Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
            Gia_ManCi( pGia, k )->Value = iNode; 
    }
    // create internal nodes
    Gia_ManHashAlloc( pNew );
    for ( k = 0; k < Gia_ManCoNum(pGia0); k++ )
    {
        Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
            Gia_ManChoiceMiter_rec( pNew, pGia, Gia_ManCo( pGia, k ) );
    }
    Gia_ManHashStop( pNew );
    // check the presence of dangling nodes
    nNodes = Gia_ManHasDangling( pNew );
    //assert( nNodes == 0 );
    // finalize
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(pGia0) );
    return pNew;
}

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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_ManCleanup()

Gia_Man_t * Gia_ManCleanup ( Gia_Man_t * p )

extern

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

Synopsis [Performs combinational cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 84 of file giaScl.c.

{
    Gia_ManCombMarkUsed( p );
    return Gia_ManDupMarked( p );
}

Here is the call graph for this function:

◆ Gia_ManCleanupOutputs()

Gia_Man_t * Gia_ManCleanupOutputs	(	Gia_Man_t *	p,
		int	nOutputs )

extern

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

Synopsis [Skip the first outputs during cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 101 of file giaScl.c.

{
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManRegNum(p) == 0 );
    assert( nOutputs < Gia_ManCoNum(p) );
    Gia_ManCombMarkUsed( p );
    Gia_ManForEachCo( p, pObj, i )
        if ( i < nOutputs )
            pObj->fMark0 = 1;
        else
            break;
    return Gia_ManDupMarked( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCleanValue()

void Gia_ManCleanValue ( Gia_Man_t * p )

extern

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_ManClockDomainNum()

int Gia_ManClockDomainNum ( Gia_Man_t * p )

extern

Definition at line 74 of file giaTim.c.

{
    int i, nDoms, Count = 0;
    if ( p->vRegClasses == NULL )
        return 0;
    nDoms = Vec_IntFindMax(p->vRegClasses);
    assert( Vec_IntCountEntry(p->vRegClasses, 0) == 0 );
    for ( i = 1; i <= nDoms; i++ )
        if ( Vec_IntCountEntry(p->vRegClasses, i) > 0 )
            Count++;
    return Count;    
}

Here is the caller graph for this function:

◆ Gia_ManCollectAnds()

void Gia_ManCollectAnds	(	Gia_Man_t *	p,
		int *	pNodes,
		int	nNodes,
		Vec_Int_t *	vNodes,
		Vec_Int_t *	vLeaves )

extern

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 125 of file giaDfs.c.

{
    int i, iLeaf; 
//    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrentId( p, 0 );
    if ( vLeaves )
        Vec_IntForEachEntry( vLeaves, iLeaf, i )
            Gia_ObjSetTravIdCurrentId( p, iLeaf );
    Vec_IntClear( vNodes );
    for ( i = 0; i < nNodes; i++ )
    {
        Gia_Obj_t * pObj = Gia_ManObj( p, pNodes[i] );
        if ( Gia_ObjIsCo(pObj) )
            Gia_ManCollectAnds_rec( p, Gia_ObjFaninId0(pObj, pNodes[i]), vNodes );
        else if ( Gia_ObjIsAnd(pObj) )
            Gia_ManCollectAnds_rec( p, pNodes[i], vNodes );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCollectAnds_rec()

void Gia_ManCollectAnds_rec	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Int_t *	vNodes )

extern

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

Synopsis [Counts the support size of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 99 of file giaDfs.c.

{
    Gia_Obj_t * pObj;
    if ( Gia_ObjIsTravIdCurrentId(p, iObj) )
        return;
    Gia_ObjSetTravIdCurrentId(p, iObj);
    pObj = Gia_ManObj( p, iObj );
    if ( Gia_ObjIsCi(pObj) )
        return;
    assert( Gia_ObjIsAnd(pObj) );
    Gia_ManCollectAnds_rec( p, Gia_ObjFaninId0(pObj, iObj), vNodes );
    Gia_ManCollectAnds_rec( p, Gia_ObjFaninId1(pObj, iObj), vNodes );
    Vec_IntPush( vNodes, iObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCollectAndsAll()

Vec_Int_t * Gia_ManCollectAndsAll ( Gia_Man_t * p )

extern

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 155 of file giaDfs.c.

{
    Gia_Obj_t * pObj; int i;
    Vec_Int_t * vNodes = Vec_IntAlloc( Gia_ManAndNum(p) );
    Gia_ManForEachAnd( p, pObj, i )
        Vec_IntPush( vNodes, i );
    return vNodes;
}

◆ Gia_ManCollectCis()

void Gia_ManCollectCis	(	Gia_Man_t *	p,
		int *	pNodes,
		int	nNodes,
		Vec_Int_t *	vSupp )

extern

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file giaDfs.c.

{
    Gia_Obj_t * pObj;
    int i; 
    Vec_IntClear( vSupp );
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < nNodes; i++ )
    {
        pObj = Gia_ManObj( p, pNodes[i] );
        if ( Gia_ObjIsCo(pObj) )
            Gia_ManCollectCis_rec( p, Gia_ObjFanin0(pObj), vSupp );
        else
            Gia_ManCollectCis_rec( p, pObj, vSupp );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCollectNodesCis()

Vec_Int_t * Gia_ManCollectNodesCis	(	Gia_Man_t *	p,
		int *	pNodes,
		int	nNodes )

extern

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file giaDfs.c.

{
    Vec_Int_t * vNodes;
    Gia_Obj_t * pObj;
    int i; 
    vNodes = Vec_IntAlloc( 10000 );
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < nNodes; i++ )
    {
        pObj = Gia_ManObj( p, pNodes[i] );
        if ( Gia_ObjIsCo(pObj) )
            Gia_ManCollectNodesCis_rec( p, Gia_ObjFanin0(pObj), vNodes );
        else
            Gia_ManCollectNodesCis_rec( p, pObj, vNodes );
    }
    return vNodes;
}

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 )

extern

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_ManCollectSuppNew()

Vec_Int_t * Gia_ManCollectSuppNew	(	Gia_Man_t *	p,
		int	iOut,
		int	nOuts )

extern

Definition at line 632 of file giaMinLut.c.

{
    Vec_Int_t * vRes = Gia_ManCollectSupp( p, iOut, nOuts );
    Gia_ManPermuteSupp( p, iOut, nOuts, vRes );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCollectTfi()

void Gia_ManCollectTfi	(	Gia_Man_t *	p,
		Vec_Int_t *	vRoots,
		Vec_Int_t *	vNodes )

extern

Definition at line 581 of file giaDfs.c.

{
    int i, iRoot; 
    Vec_IntClear( vNodes );
    Gia_ManIncrementTravId( p );
    Vec_IntForEachEntry( vRoots, iRoot, i )
        Gia_ManCollectTfi_rec( p, iRoot, vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCollectTfo()

void Gia_ManCollectTfo	(	Gia_Man_t *	p,
		Vec_Int_t *	vRoots,
		Vec_Int_t *	vNodes )

extern

Definition at line 615 of file giaDfs.c.

{
    int i, iRoot; 
    Vec_IntClear( vNodes );
    Gia_ManIncrementTravId( p );
    Vec_IntForEachEntry( vRoots, iRoot, i )
        Gia_ManCollectTfo_rec( p, iRoot, vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManCombMarkUsed()

int Gia_ManCombMarkUsed ( Gia_Man_t * p )

extern

Definition at line 60 of file giaScl.c.

{
    Gia_Obj_t * pObj;
    int i, nNodes = 0;
    Gia_ManForEachObj( p, pObj, i )
        pObj->fMark0 = Gia_ObjIsAnd(pObj) && !Gia_ObjIsBuf(pObj);
    Gia_ManForEachBuf( p, pObj, i )
        nNodes += Gia_ManCombMarkUsed_rec( p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        nNodes += Gia_ManCombMarkUsed_rec( p, Gia_ObjFanin0(pObj) );
    return nNodes;
}

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 )

extern

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_ManComputeDistance()

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

extern

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_ManComputeEdgeDelay()

int Gia_ManComputeEdgeDelay	(	Gia_Man_t *	p,
		int	fUseTwo )

extern

Definition at line 390 of file giaEdge.c.

{
    int k, iLut, DelayMax = 0;
    Vec_IntFreeP( &p->vEdgeDelay );
    Vec_IntFreeP( &p->vEdge1 );
    Vec_IntFreeP( &p->vEdge2 );
    p->vEdge1 = Vec_IntStart( Gia_ManObjNum(p) );
    p->vEdge2 = Vec_IntStart( Gia_ManObjNum(p) );
    p->vEdgeDelay = Vec_IntStart( Gia_ManObjNum(p) );
    if ( Gia_ManHasMapping(p) )
    {
        if ( p->pManTime != NULL && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) )
        {
            Gia_Obj_t * pObj; 
            Vec_Int_t * vNodes = Gia_ManOrderWithBoxes( p );
            Tim_ManIncrementTravId( (Tim_Man_t*)p->pManTime );
            Gia_ManForEachObjVec( vNodes, p, pObj, k )
            {
                iLut = Gia_ObjId( p, pObj );
                if ( Gia_ObjIsAnd(pObj) )
                {
                    if ( Gia_ObjIsLut(p, iLut) )
                        Gia_ObjComputeEdgeDelay( p, iLut, p->vEdgeDelay, p->vEdge1, p->vEdge2, fUseTwo );
                }
                else if ( Gia_ObjIsCi(pObj) )
                {
                    int arrTime = Tim_ManGetCiArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj) );
                    Vec_IntWriteEntry( p->vEdgeDelay,  iLut, arrTime );
                }
                else if ( Gia_ObjIsCo(pObj) )
                {
                    int arrTime = Vec_IntEntry( p->vEdgeDelay, Gia_ObjFaninId0(pObj, iLut) );
                    Tim_ManSetCoArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj), arrTime );
                }
                else if ( !Gia_ObjIsConst0(pObj) ) 
                    assert( 0 );
            }
            Vec_IntFree( vNodes );
        }
        else
        {
            Gia_ManForEachLut( p, iLut )
                Gia_ObjComputeEdgeDelay( p, iLut, p->vEdgeDelay, p->vEdge1, p->vEdge2, fUseTwo );
        }
    }
    else if ( Gia_ManHasMapping2(p) )
    {
        if ( p->pManTime != NULL && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) )
        {
            Gia_Obj_t * pObj; 
            Vec_Int_t * vNodes = Gia_ManOrderWithBoxes( p );
            Tim_ManIncrementTravId( (Tim_Man_t*)p->pManTime );
            Gia_ManForEachObjVec( vNodes, p, pObj, k )
            {
                iLut = Gia_ObjId( p, pObj );
                if ( Gia_ObjIsAnd(pObj) )
                {
                    if ( Gia_ObjIsLut2(p, iLut) )
                        Gia_ObjComputeEdgeDelay( p, iLut, p->vEdgeDelay, p->vEdge1, p->vEdge2, fUseTwo );
                }
                else if ( Gia_ObjIsCi(pObj) )
                {
                    int arrTime = Tim_ManGetCiArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj) );
                    Vec_IntWriteEntry( p->vEdgeDelay,  iLut, arrTime );
                }
                else if ( Gia_ObjIsCo(pObj) )
                {
                    int arrTime = Vec_IntEntry( p->vEdgeDelay, Gia_ObjFaninId0(pObj, iLut) );
                    Tim_ManSetCoArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj), arrTime );
                }
                else if ( !Gia_ObjIsConst0(pObj) ) 
                    assert( 0 );
            }
            Vec_IntFree( vNodes );
        }
        else
        {
            Gia_ManForEachLut2( p, iLut )
                Gia_ObjComputeEdgeDelay( p, iLut, p->vEdgeDelay, p->vEdge1, p->vEdge2, fUseTwo );
        }
    }
    else assert( 0 );
    Gia_ManForEachCoDriverId( p, iLut, k )
        DelayMax = Abc_MaxInt( DelayMax, Vec_IntEntry(p->vEdgeDelay, iLut) );
    //printf( "The number of edges = %d.  Delay = %d.\n", Gia_ManEvalEdgeCount(p), DelayMax );
    return DelayMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeEdgeDelay2()

int Gia_ManComputeEdgeDelay2 ( Gia_Man_t * p )

extern

Definition at line 568 of file giaEdge.c.

{
    int k, iLut, DelayMax = 0;
    Vec_Int_t * vFanMax1 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vFanMax2 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_Int_t * vCountMax = Vec_IntStart( Gia_ManObjNum(p) );
    assert( p->pManTime == NULL );
    Vec_IntFreeP( &p->vEdgeDelay );
    Vec_IntFreeP( &p->vEdge1 );
    Vec_IntFreeP( &p->vEdge2 );
    p->vEdgeDelay = Vec_IntStart( Gia_ManObjNum(p) );
    p->vEdge1 = Vec_IntStart( Gia_ManObjNum(p) );
    p->vEdge2 = Vec_IntStart( Gia_ManObjNum(p) );
//    Gia_ManForEachCoDriverId( p, iLut, k )
//        Vec_IntWriteEntry( p->vEdgeDelay, iLut, 1 );
    if ( Gia_ManHasMapping(p) )
        Gia_ManForEachLutReverse( p, iLut )
            Gia_ObjComputeEdgeDelay2( p, iLut, p->vEdgeDelay, p->vEdge1, p->vEdge2, vFanMax1, vFanMax2, vCountMax );
    else if ( Gia_ManHasMapping2(p) )
        Gia_ManForEachLut2Reverse( p, iLut )
            Gia_ObjComputeEdgeDelay2( p, iLut, p->vEdgeDelay, p->vEdge1, p->vEdge2, vFanMax1, vFanMax2, vCountMax );
    else assert( 0 );
    Gia_ManForEachCiId( p, iLut, k )
        DelayMax = Abc_MaxInt( DelayMax, Vec_IntEntry(p->vEdgeDelay, iLut) );
    Vec_IntFree( vFanMax1 );
    Vec_IntFree( vFanMax2 );
    Vec_IntFree( vCountMax );
    //printf( "The number of edges = %d.  Delay = %d.\n", Gia_ManEvalEdgeCount(p), DelayMax );
    return DelayMax;
}

Here is the call graph for this function:

◆ Gia_ManComputeGiaEquivs()

Gia_Man_t * Gia_ManComputeGiaEquivs	(	Gia_Man_t *	pGia,
		int	nConfs,
		int	fVerbose )

extern

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

Synopsis [Compute equivalence classes of nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 183 of file giaEquiv.c.

{
    Gia_Man_t * pTemp;
    Cec_ParFra_t ParsFra, * pPars = &ParsFra;
    Cec_ManFraSetDefaultParams( pPars );
    pPars->nItersMax = 100;
    pPars->fUseOrigIds = 1;
    pPars->fSatSweeping = 1;
    pPars->nBTLimit = nConfs;
    pPars->fVerbose = fVerbose;
    pTemp = Cec_ManSatSweeping( pGia, pPars, 0 );
    Gia_ManStop( pTemp );
    return Gia_ManOrigIdsReduce( pGia, pGia->vIdsEquiv );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeOneWin()

int Gia_ManComputeOneWin	(	Gia_Man_t *	pGia,
		int	iPivot,
		Vec_Int_t **	pvRoots,
		Vec_Int_t **	pvNodes,
		Vec_Int_t **	pvLeaves,
		Vec_Int_t **	pvAnds )

extern

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

Synopsis [External procedures.]

Description []

SideEffects []

SeeAlso []

Definition at line 516 of file giaSplit.c.

{
    Spl_Man_t * p = (Spl_Man_t *)pGia->pSatlutWinman;
    assert( p != NULL );
    if ( iPivot == -1 )
    {
        Spl_ManStop( p );
        pGia->pSatlutWinman = NULL;
        return 0;
    }
    if ( !Spl_ManComputeOne( p, iPivot ) )
    {
        *pvRoots  = NULL;
        *pvNodes  = NULL;
        *pvLeaves = NULL;
        *pvAnds   = NULL;
        return 0;
    }
    *pvRoots  = p->vRoots;
    *pvNodes  = p->vNodes;
    *pvLeaves = p->vLeaves;
    *pvAnds   = p->vAnds;
    // Vec_IntPrint( p->vNodes );
    return Vec_IntSize(p->vAnds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeOneWinStart()

void Gia_ManComputeOneWinStart	(	Gia_Man_t *	p,
		int	nAnds,
		int	fReverse )

extern

Definition at line 541 of file giaSplit.c.

{
    assert( pGia->pSatlutWinman == NULL );
    pGia->pSatlutWinman = Spl_ManAlloc( pGia, nAnds, fReverse );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeRange()

Vec_Str_t * Gia_ManComputeRange ( Gia_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 3685 of file giaSimBase.c.

{
    Vec_Wrd_t * vSimsPi = Vec_WrdStartTruthTables( Gia_ManCiNum(p) );
    Vec_Wrd_t * vSims   = Gia_ManSimPatSimOut( p, vSimsPi, 1 );
    int n, nWords = Vec_WrdSize(vSimsPi) / Gia_ManCiNum(p);
    int i, nLimit = Gia_ManCiNum(p) < 6 ? 1 << Gia_ManCiNum(p) : 64*nWords;
    Vec_Str_t * vOut = Vec_StrAlloc( nLimit*(Gia_ManCoNum(p) + 3)+1 );
    assert( Vec_WrdSize(vSims) == nWords * Gia_ManCoNum(p) );
    for ( n = 0; n < nLimit; n++ )
    {
        for ( i = 0; i < Gia_ManCoNum(p); i++ )
            Vec_StrPush( vOut, (char)('0' + Abc_TtGetBit(Vec_WrdEntryP(vSims, i*nWords), n)) );
        Vec_StrPush( vOut, ' ' );
        Vec_StrPush( vOut, '1' );
        Vec_StrPush( vOut, '\n' );
    }
    Vec_StrPush( vOut, '\0' );
    Vec_WrdFree( vSims );
    Vec_WrdFree( vSimsPi );
    return vOut;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeSwitching()

float Gia_ManComputeSwitching	(	Gia_Man_t *	p,
		int	nFrames,
		int	nPref,
		int	fProbOne )

extern

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

Synopsis [Computes probability of switching (or of being 1).]

Description []

SideEffects []

SeeAlso []

Definition at line 808 of file giaSwitch.c.

{
    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)];
    }
    if ( 0 )
    {
        Gia_ManForEachObj( p, pObj, i )
        {
            printf( "Switch %6.2f  ", pSwi[i] );
            Gia_ObjPrint( p, pObj );
        }
    }
    Vec_IntFree( vSwitching );
    return SwiTotal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeSwitchProbs()

Vec_Int_t * Gia_ManComputeSwitchProbs	(	Gia_Man_t *	pGia,
		int	nFrames,
		int	nPref,
		int	fProbOne )

extern

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

Synopsis [Computes probability of switching (or of being 1).]

Description []

SideEffects []

SeeAlso []

Definition at line 658 of file giaSwitch.c.

{
    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 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManComputeSwitchProbs2()

Vec_Int_t * Gia_ManComputeSwitchProbs2	(	Gia_Man_t *	pGia,
		int	nFrames,
		int	nPref,
		int	fProbOne,
		int	nRandPiFactor )

extern

Definition at line 684 of file giaSwitch.c.

{
    Gia_ParSwi_t Pars, * pPars = &Pars;
    // set the default parameters
    Gia_ManSetDefaultParamsSwi( pPars );
    pPars->nRandPiFactor = nRandPiFactor;
    // 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 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManConeSize()

int Gia_ManConeSize	(	Gia_Man_t *	p,
		int *	pNodes,
		int	nNodes )

extern

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 375 of file giaDfs.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0; 
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < nNodes; i++ )
    {
        pObj = Gia_ManObj( p, pNodes[i] );
        if ( Gia_ObjIsCo(pObj) )
            Counter += Gia_ManConeSize_rec( p, Gia_ObjFanin0(pObj) );
        else
            Counter += Gia_ManConeSize_rec( p, pObj );
    }
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManConvertAigToTruth()

unsigned * Gia_ManConvertAigToTruth	(	Gia_Man_t *	p,
		Gia_Obj_t *	pRoot,
		Vec_Int_t *	vLeaves,
		Vec_Int_t *	vTruth,
		Vec_Int_t *	vVisited )

extern

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

Synopsis [Computes truth table of the node.]

Description [Assumes that the structural support is no more than 8 inputs. Uses array vTruth to store temporary truth tables. The returned pointer should be used immediately.]

SideEffects []

SeeAlso []

Definition at line 90 of file giaBidec.c.

{
    static unsigned uTruths[8][8] = { // elementary truth tables
        { 0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA,0xAAAAAAAA },
        { 0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC,0xCCCCCCCC },
        { 0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0,0xF0F0F0F0 },
        { 0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00,0xFF00FF00 },
        { 0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000,0xFFFF0000 }, 
        { 0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF,0x00000000,0xFFFFFFFF }, 
        { 0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF }, 
        { 0x00000000,0x00000000,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF } 
    };
    Gia_Obj_t * pObj;
    Vec_Ptr_t * vTtElems = NULL;
    unsigned * pTruth;//, * pTruth2;
    int i, nWords, nVars;
    // get the number of variables and words
    nVars  = Vec_IntSize( vLeaves );
    nWords = Abc_TruthWordNum( nVars );
    // check the case of a constant
    if ( Gia_ObjIsConst0( Gia_Regular(pRoot) ) )
    {
        Vec_IntClear( vTruth );
        // get room for the truth table
        pTruth = Vec_IntFetch( vTruth, nWords );
        if ( !Gia_IsComplement(pRoot) )
            Gia_ManTruthClear( pTruth, nVars );
        else
            Gia_ManTruthFill( pTruth, nVars );
        return pTruth;
    }
    // if the number of variables is more than 8, allocate truth tables
    if ( nVars > 8 )
        vTtElems = Vec_PtrAllocTruthTables( nVars );
    // assign elementary truth tables
    Vec_IntClear( vTruth );
    Vec_IntClear( vVisited );
    Gia_ManForEachObjVec( vLeaves, p, pObj, i )
    {
        // get room for the truth table
        pTruth = Vec_IntFetch( vTruth, nWords );
        // assign elementary variable
        if ( vTtElems )
            Gia_ManTruthCopy( pTruth, (unsigned *)Vec_PtrEntry(vTtElems, i), nVars );
        else
            Gia_ManTruthCopy( pTruth, uTruths[i], nVars );
        // save the visited node
        Vec_IntSetEntry( p->vTruths, Gia_ObjId(p, pObj), Vec_IntSize(vVisited) );
        Vec_IntPush( vVisited, Gia_ObjId(p, pObj) );
    }
    if ( vTtElems )
        Vec_PtrFree( vTtElems );
    // clear the marks and compute the truth table
//    pTruth2 = Gia_ManConvertAigToTruth_rec( p, Gia_Regular(pRoot), vTruth, nWords, vVisited );
    pTruth = Gia_ManConvertAigToTruth_rec( p, Gia_Regular(pRoot), vTruth, nWords, vVisited );
    // copy the result
//    Gia_ManTruthCopy( pTruth, pTruth2, nVars );
    if ( Gia_IsComplement(pRoot) )
        Gia_ManTruthNot( pTruth, pTruth, nVars );
    // clean truth tables
    Gia_ManForEachObjVec( vVisited, p, pObj, i )
        Vec_IntSetEntry( p->vTruths, Gia_ObjId(p, pObj), -1 );
    return pTruth;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManConvertPackingToEdges()

void Gia_ManConvertPackingToEdges ( Gia_Man_t * p )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 118 of file giaEdge.c.

{
    int i, k, Entry, nEntries, nEntries2, nNodes[4], Count = 0;
    if ( p->vPacking == NULL )
        return;
    Vec_IntFreeP( &p->vEdge1 );
    Vec_IntFreeP( &p->vEdge2 );
    p->vEdge1 = Vec_IntStart( Gia_ManObjNum(p) );
    p->vEdge2 = Vec_IntStart( Gia_ManObjNum(p) );
    // iterate through structures
    nEntries = Vec_IntEntry( p->vPacking, 0 );
    nEntries2 = 0;
    Vec_IntForEachEntryStart( p->vPacking, Entry, i, 1 )
    {
        assert( Entry > 0 && Entry < 4 );
        i++;
        for ( k = 0; k < Entry; k++, i++ )
            nNodes[k] = Vec_IntEntry(p->vPacking, i);
        i--;
        nEntries2++;
        // create edges
        if ( Entry == 2 )
        {
            Count += Gia_ObjEdgeAdd( nNodes[0], nNodes[1], p->vEdge1, p->vEdge2 );
            Count += Gia_ObjEdgeAdd( nNodes[1], nNodes[0], p->vEdge1, p->vEdge2 );
        }
        else if ( Entry == 3 )
        {
            Count += Gia_ObjEdgeAdd( nNodes[0], nNodes[2], p->vEdge1, p->vEdge2 );
            Count += Gia_ObjEdgeAdd( nNodes[2], nNodes[0], p->vEdge1, p->vEdge2 );
            Count += Gia_ObjEdgeAdd( nNodes[1], nNodes[2], p->vEdge1, p->vEdge2 );
            Count += Gia_ObjEdgeAdd( nNodes[2], nNodes[1], p->vEdge1, p->vEdge2 );
        }
    }
    assert( nEntries == nEntries2 );
    if ( Count )
        printf( "Skipped %d illegal edges.\n", Count );
}

Here is the caller graph for this function:

◆ Gia_ManCountChoiceNodes()

int Gia_ManCountChoiceNodes ( Gia_Man_t * p )

extern

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

Synopsis [Counts the number of choice nodes]

Description []

SideEffects []

SeeAlso []

Definition at line 2091 of file giaEquiv.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0;
    if ( p->pReprs == NULL || p->pNexts == NULL )
        return 0;
    Gia_ManForEachObj( p, pObj, i )
        Counter += Gia_ObjIsHead( p, i );
    return Counter;
}

◆ Gia_ManCountChoices()

int Gia_ManCountChoices ( Gia_Man_t * p )

extern

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

Synopsis [Counts the number of choices]

Description []

SideEffects []

SeeAlso []

Definition at line 2113 of file giaEquiv.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0;
    if ( p->pReprs == NULL || p->pNexts == NULL )
        return 0;
    Gia_ManForEachObj( p, pObj, i )
        Counter += (int)(Gia_ObjNext( p, i ) > 0);
    return Counter;
}

◆ Gia_ManCounterExampleValueLookup()

int Gia_ManCounterExampleValueLookup	(	Gia_Man_t *	pGia,
		int	Id,
		int	iFrame )

extern

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

Synopsis [Returns the value of the given object in the given timeframe.]

Description [Should be called to probe the value of an object with the given ID (iFrame is a 0-based number of a time frame - should not exceed the number of timeframes in the original counter-example).]

SideEffects []

SeeAlso []

Definition at line 266 of file giaCex.c.

{
    assert( Id >= 0 && Id < Gia_ManObjNum(pGia) );
    return Abc_InfoHasBit( (unsigned *)pGia->pData2, Gia_ManObjNum(pGia) * iFrame + Id );
}

Here is the caller graph for this function:

◆ Gia_ManCounterExampleValueStart()

void Gia_ManCounterExampleValueStart	(	Gia_Man_t *	pGia,
		Abc_Cex_t *	pCex )

extern

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

Synopsis [Starts the process of returning values for internal nodes.]

Description [Should be called when pCex is available, before probing any object for its value using Gia_ManCounterExampleValueLookup().]

SideEffects []

SeeAlso []

Definition at line 188 of file giaCex.c.

{
    Gia_Obj_t * pObj, * pObjRi, * pObjRo;
    int Val0, Val1, nObjs, i, k, iBit = 0;
    assert( Gia_ManRegNum(pGia) > 0 ); // makes sense only for sequential AIGs
    assert( pGia->pData2 == NULL );    // if this fail, there may be a memory leak
    // allocate memory to store simulation bits for internal nodes
    pGia->pData2 = ABC_CALLOC( unsigned, Abc_BitWordNum( (pCex->iFrame + 1) * Gia_ManObjNum(pGia) ) );
    // the register values in the counter-example should be zero
    Gia_ManForEachRo( pGia, pObj, k )
        assert( Abc_InfoHasBit(pCex->pData, iBit) == 0 ), iBit++;
    // iterate through the timeframes
    nObjs = Gia_ManObjNum(pGia);
    for ( i = 0; i <= pCex->iFrame; i++ )
    {
        // no need to set constant-0 node
        // set primary inputs according to the counter-example
        Gia_ManForEachPi( pGia, pObj, k )
            if ( Abc_InfoHasBit(pCex->pData, iBit++) )
                Abc_InfoSetBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjId(pGia, pObj) );
        // compute values for each node
        Gia_ManForEachAnd( pGia, pObj, k )
        {
            Val0 = Abc_InfoHasBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjFaninId0p(pGia, pObj) );
            Val1 = Abc_InfoHasBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjFaninId1p(pGia, pObj) );
            if ( (Val0 ^ Gia_ObjFaninC0(pObj)) & (Val1 ^ Gia_ObjFaninC1(pObj)) )
                Abc_InfoSetBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjId(pGia, pObj) );
        }
        // derive values for combinational outputs
        Gia_ManForEachCo( pGia, pObj, k )
        {
            Val0 = Abc_InfoHasBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjFaninId0p(pGia, pObj) );
            if ( Val0 ^ Gia_ObjFaninC0(pObj) )
                Abc_InfoSetBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjId(pGia, pObj) );
        }
        if ( i == pCex->iFrame )
            continue;
        // transfer values to the register output of the next frame
        Gia_ManForEachRiRo( pGia, pObjRi, pObjRo, k )
            if ( Abc_InfoHasBit( (unsigned *)pGia->pData2, nObjs * i + Gia_ObjId(pGia, pObjRi) ) )
                Abc_InfoSetBit( (unsigned *)pGia->pData2, nObjs * (i+1) + Gia_ObjId(pGia, pObjRo) );
    }
    assert( iBit == pCex->nBits );
    // check that the counter-example is correct, that is, the corresponding output is asserted
    assert( Abc_InfoHasBit( (unsigned *)pGia->pData2, nObjs * pCex->iFrame + Gia_ObjId(pGia, Gia_ManCo(pGia, pCex->iPo)) ) );
}

Here is the caller graph for this function:

◆ Gia_ManCounterExampleValueStop()

void Gia_ManCounterExampleValueStop ( Gia_Man_t * pGia )

extern

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

Synopsis [Stops the process of returning values for internal nodes.]

Description [Should be called when probing is no longer needed]

SideEffects []

SeeAlso []

Definition at line 246 of file giaCex.c.

{
    assert( pGia->pData2 != NULL );    // if this fail, we try to call this procedure more than once
    ABC_FREE( pGia->pData2 );
    pGia->pData2 = NULL;
}

Here is the caller graph for this function:

◆ Gia_ManCountFraction()

word * Gia_ManCountFraction	(	Gia_Man_t *	p,
		Vec_Wrd_t *	vSimI,
		Vec_Int_t *	vSupp,
		int	Thresh,
		int	fVerbose,
		int *	pCare )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 531 of file giaMinLut.c.

{
    Gia_Obj_t * pObj;
    int i, k, nUsed = 0, nGood = 0;
    int nWords = Vec_WrdSize(vSimI) / Gia_ManCiNum(p);
    int nMints = 1 << Vec_IntSize(vSupp);
    word ** pSims = ABC_ALLOC( word *, Vec_IntSize(vSupp) );
    word * pRes   = ABC_CALLOC( word, Abc_Truth6WordNum(Vec_IntSize(vSupp)) );
    int * pCounts = ABC_CALLOC( int, nMints );
    Gia_ManForEachObjVec( vSupp, p, pObj, i )
        pSims[i] = Vec_WrdEntryP( vSimI, Gia_ObjCioId(pObj) * nWords );
    for ( k = 0; k < 64*nWords; k++ )
    {
        int iMint = 0;
        for ( i = 0; i < Vec_IntSize(vSupp); i++ )
            if ( Abc_TtGetBit(pSims[i], k) )
                iMint |= 1 << i;
        assert( iMint < nMints );
        pCounts[iMint]++;
    }
    for ( k = 0; k < nMints; k++ )
    {
        nUsed += (pCounts[k] > 0);
        nGood += (pCounts[k] >= Thresh);
        if ( pCounts[k] >= Thresh )
            Abc_TtXorBit( pRes, k );
        //printf( "%d ", pCounts[k] );
    }
    if ( Vec_IntSize(vSupp) < 6 )
        pRes[0] = Abc_Tt6Stretch( pRes[0], Vec_IntSize(vSupp) );
    //printf( "\n" );
    if ( fVerbose )
    printf( "Used %4d and good %4d (out of %4d).\n", nUsed, nGood, nMints ); 
    ABC_FREE( pSims );
    ABC_FREE( pCounts );
    *pCare = nGood;
    return pRes;
}

Here is the caller graph for this function:

◆ Gia_ManCountMuxXor()

void Gia_ManCountMuxXor	(	Gia_Man_t *	p,
		int *	pnMuxes,
		int *	pnXors )

extern

DECLARATIONS ///.

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

FileName [giaMuxes.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Multiplexer profiling algorithm.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Counts XORs and MUXes.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file giaMuxes.c.

{
    Gia_Obj_t * pObj, * pFan0, * pFan1; int i;
    *pnMuxes = *pnXors = 0;
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( !Gia_ObjIsMuxType(pObj) )
            continue;
        if ( Gia_ObjRecognizeExor(pObj, &pFan0, &pFan1) )
            (*pnXors)++;
        else
            (*pnMuxes)++;
    }
}

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 )

extern

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 )

extern

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_ManCreateLitRefs()

void Gia_ManCreateLitRefs ( Gia_Man_t * p )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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_ManDelayTraceLut()

float Gia_ManDelayTraceLut ( Gia_Man_t * p )

extern

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

Synopsis [Computes the delay trace of the given network.]

Description []

SideEffects []

SeeAlso []

Definition at line 230 of file giaSpeedup.c.

{
    int fUseSorting = 1;
    If_LibLut_t * pLutLib = (If_LibLut_t *)p->pLutLib;
    Vec_Int_t * vObjs;
    Gia_Obj_t * pObj;
    float tArrival, tArrivalCur, tRequired, tSlack;
    int i, iObj;
 
    // get the library
    if ( pLutLib && pLutLib->LutMax < Gia_ManLutSizeMax(p) )
    {
        printf( "The max LUT size (%d) is less than the max fanin count (%d).\n", 
            pLutLib->LutMax, Gia_ManLutSizeMax(p) );
        return -TIM_ETERNITY;
    }
 
    // initialize the arrival times
    Gia_ManTimeStart( p );
    Gia_ManLevelNum( p );
 
    // propagate arrival times
    if ( p->pManTime )
        Tim_ManIncrementTravId( (Tim_Man_t *)p->pManTime );
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( !Gia_ObjIsCi(pObj) && !Gia_ObjIsCo(pObj) && !Gia_ObjIsLut(p, i) )
            continue;
        tArrival = Gia_ObjComputeArrival( p, i, fUseSorting );
        if ( Gia_ObjIsCi(pObj) && p->pManTime )
        {
            tArrival = Tim_ManGetCiArrival( (Tim_Man_t *)p->pManTime, Gia_ObjCioId(pObj) );
//printf( "%.3f  ", tArrival );
        }
        if ( Gia_ObjIsCo(pObj) && p->pManTime )
            Tim_ManSetCoArrival( (Tim_Man_t *)p->pManTime, Gia_ObjCioId(pObj), tArrival );
        Gia_ObjSetTimeArrival( p, i, tArrival );
    }
 
    // get the latest arrival times
    tArrival = -TIM_ETERNITY;
    Gia_ManForEachCo( p, pObj, i )
    {
        tArrivalCur = Gia_ObjTimeArrivalObj( p, Gia_ObjFanin0(pObj) );
        Gia_ObjSetTimeArrival( p, Gia_ObjId(p,pObj), tArrivalCur );
        if ( tArrival < tArrivalCur )
            tArrival = tArrivalCur;
    }
 
    // initialize the required times
    if ( p->pManTime )
    {
        Tim_ManIncrementTravId( (Tim_Man_t *)p->pManTime );
        Tim_ManInitPoRequiredAll( (Tim_Man_t *)p->pManTime, tArrival );
    }
    else
    {
        Gia_ManForEachCo( p, pObj, i )
            Gia_ObjSetTimeRequiredObj( p, pObj, tArrival );
    }
 
    // propagate the required times
    vObjs = Gia_ManOrderReverse( p );
    Vec_IntForEachEntry( vObjs, iObj, i )
    {
        pObj = Gia_ManObj(p, iObj);
        if ( Gia_ObjIsLut(p, iObj) )
        {
            Gia_ObjPropagateRequired( p, iObj, fUseSorting );
        }
        else if ( Gia_ObjIsCi(pObj) )
        {
            if ( p->pManTime )
                Tim_ManSetCiRequired( (Tim_Man_t *)p->pManTime, Gia_ObjCioId(pObj), Gia_ObjTimeRequired(p, iObj) );
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            if ( p->pManTime )
            {
                tRequired = Tim_ManGetCoRequired( (Tim_Man_t *)p->pManTime, Gia_ObjCioId(pObj) );
                Gia_ObjSetTimeRequired( p, iObj, tRequired );
            }
            if ( Gia_ObjTimeRequired(p, Gia_ObjFaninId0p(p, pObj)) > Gia_ObjTimeRequired(p, iObj) )
                Gia_ObjSetTimeRequired(p, Gia_ObjFaninId0p(p, pObj), Gia_ObjTimeRequired(p, iObj) );
        }
 
        // set slack for this object
        tSlack = Gia_ObjTimeRequired(p, iObj) - Gia_ObjTimeArrival(p, iObj);
        assert( tSlack + 0.01 > 0.0 );
        Gia_ObjSetTimeSlack( p, iObj, tSlack < 0.0 ? 0.0 : tSlack );
    }
    Vec_IntFree( vObjs );
    return tArrival;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDelayTraceLutPrint()

float Gia_ManDelayTraceLutPrint	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis [Prints the delay trace for the given network.]

Description []

SideEffects []

SeeAlso []

Definition at line 444 of file giaSpeedup.c.

{
    If_LibLut_t * pLutLib = (If_LibLut_t *)p->pLutLib;
    int i, Nodes, * pCounters;
    float tArrival, tDelta, nSteps, Num;
    // get the library
    if ( pLutLib && pLutLib->LutMax < Gia_ManLutSizeMax(p) )
    {
        printf( "The max LUT size (%d) is less than the max fanin count (%d).\n", 
            pLutLib->LutMax, Gia_ManLutSizeMax(p) );
        return -ABC_INFINITY;
    }
    // decide how many steps
    nSteps = pLutLib ? 20 : Gia_ManLutLevel(p, NULL);
    pCounters = ABC_ALLOC( int, nSteps + 1 );
    memset( pCounters, 0, sizeof(int)*(nSteps + 1) );
    // perform delay trace
    tArrival = Gia_ManDelayTraceLut( p );
    tDelta   = tArrival / nSteps;
    // count how many nodes have slack in the corresponding intervals
    Gia_ManForEachLut( p, i )
    {
        if ( Gia_ObjLutSize(p, i) == 0 )
            continue;
        Num = Gia_ObjTimeSlack(p, i) / tDelta;
        if ( Num > nSteps )
            continue;
        assert( Num >=0 && Num <= nSteps );
        pCounters[(int)Num]++;
    }
    // print the results    
    if ( fVerbose )
    {
        printf( "Max delay = %6.2f. Delay trace using %s model:\n", tArrival, pLutLib? "LUT library" : "unit-delay" );
        Nodes = 0;
        for ( i = 0; i < nSteps; i++ )
        {
            Nodes += pCounters[i];
            printf( "%3d %s : %5d  (%6.2f %%)\n", pLutLib? 5*(i+1) : i+1, 
                pLutLib? "%":"lev", Nodes, 100.0*Nodes/Gia_ManLutNum(p) );
        }
    }
    ABC_FREE( pCounters );
    Gia_ManTimeStop( p );
    return tArrival;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDemiterDual()

int Gia_ManDemiterDual	(	Gia_Man_t *	p,
		Gia_Man_t **	pp0,
		Gia_Man_t **	pp1 )

extern

Definition at line 5030 of file giaDup.c.

{
    Gia_Obj_t * pObj;
    int i, fOdd;
    assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManCoNum(p) % 2 == 0 );
    *pp0 = *pp1 = NULL;
    for ( fOdd = 0; fOdd < 2; fOdd++ )
    {
        Vec_Int_t * vNodes = Gia_ManCollectReach( p, fOdd );
        Gia_Man_t * pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Vec_IntSize(vNodes) + Gia_ManCoNum(p)/2 );
        pNew->pName = Abc_UtilStrsav( p->pName );
        pNew->pSpec = Abc_UtilStrsav( p->pSpec );
        Gia_ManConst0(p)->Value = 0;
        Gia_ManForEachPi( p, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
        Gia_ManForEachObjVec( vNodes, p, pObj, i )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        Gia_ManForEachCo( p, pObj, i )
            if ( (i & 1) == fOdd )
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Vec_IntFree( vNodes );
        if ( fOdd )
            *pp1 = pNew;
        else
            *pp0 = pNew;
    }
    return 1;
}

Here is the call graph for this function:

◆ Gia_ManDemiterToDual()

Gia_Man_t * Gia_ManDemiterToDual ( Gia_Man_t * p )

extern

Definition at line 4956 of file giaDup.c.

{
    Gia_Man_t * pNew; Gia_Obj_t * pObj; int i;
    Vec_Int_t * vNodes;
    Vec_Int_t * vOrder = Gia_ManCollectTopXors( p );
    if ( vOrder == NULL )
    {
        printf( "Cannot demiter because the top-most gate is an AND-gate.\n" );
        return NULL;
    }
    assert( Vec_IntSize(vOrder) % 2 == 0 );
    vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
    Gia_ManIncrementTravId( p );
    Gia_ManCollectAnds( p, Vec_IntArray(vOrder), Vec_IntSize(vOrder), vNodes, NULL );
    pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Vec_IntSize(vNodes) + Vec_IntSize(vOrder) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    pObj = Gia_ManCo(p, 0);
    if ( Gia_ObjFanin0(pObj) == Gia_ManConst0(p) )
    {
        Gia_ManAppendCo( pNew, 0 );
        Gia_ManAppendCo( pNew, Gia_ObjFaninC0(pObj) );
    }
    else
    {
        Gia_ManSetPhase( p );
        Gia_ManForEachObjVec( vOrder, p, pObj, i )
            Gia_ManAppendCo( pNew, Abc_LitNotCond(pObj->Value, pObj->fPhase) );
    }
    Vec_IntFree( vNodes );
    Vec_IntFree( vOrder );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDemiterTwoWords()

int Gia_ManDemiterTwoWords	(	Gia_Man_t *	p,
		Gia_Man_t **	pp0,
		Gia_Man_t **	pp1 )

extern

Definition at line 5082 of file giaDup.c.

{
    Gia_Obj_t * pObj;
    int i, fSecond;
    assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManCoNum(p) % 2 == 0 );
    *pp0 = *pp1 = NULL;
    for ( fSecond = 0; fSecond < 2; fSecond++ )
    {
        Vec_Int_t * vNodes = Gia_ManCollectReach2( p, fSecond );
        Gia_Man_t * pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Vec_IntSize(vNodes) + Gia_ManCoNum(p)/2 );
        pNew->pName = Abc_UtilStrsav( p->pName );
        pNew->pSpec = Abc_UtilStrsav( p->pSpec );
        Gia_ManConst0(p)->Value = 0;
        Gia_ManForEachPi( p, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
        Gia_ManForEachObjVec( vNodes, p, pObj, i )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        Gia_ManForEachCo( p, pObj, i )
            if ( (i < Gia_ManCoNum(p)/2) ^ fSecond )
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Vec_IntFree( vNodes );
        if ( fSecond )
            *pp1 = pNew;
        else
            *pp0 = pNew;
    }
    return 1;
}

Here is the call graph for this function:

◆ Gia_ManDeriveNexts()

int * Gia_ManDeriveNexts ( Gia_Man_t * p )

extern

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

Synopsis [Given representatives, derives pointers to the next objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 260 of file giaEquiv.c.

{
    unsigned * pNexts, * pTails;
    int i;
    assert( p->pReprs != NULL );
    assert( p->pNexts == NULL );
    pNexts = ABC_CALLOC( unsigned, Gia_ManObjNum(p) );
    pTails = ABC_ALLOC( unsigned, Gia_ManObjNum(p) );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
        pTails[i] = i;
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
    {
        //if ( p->pReprs[i].iRepr == GIA_VOID )
        if ( !p->pReprs[i].iRepr || p->pReprs[i].iRepr == GIA_VOID )
            continue;
        pNexts[ pTails[p->pReprs[i].iRepr] ] = i;
        pTails[p->pReprs[i].iRepr] = i;
    }
    ABC_FREE( pTails );
    return (int *)pNexts;
}

Here is the caller graph for this function:

◆ Gia_ManDeriveReprs()

void Gia_ManDeriveReprs ( Gia_Man_t * p )

extern

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

Synopsis [Given points to the next objects, derives representatives.]

Description []

SideEffects []

SeeAlso []

Definition at line 293 of file giaEquiv.c.

{
    int i, iObj;
    assert( p->pReprs == NULL );
    assert( p->pNexts != NULL );
    p->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p) );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
        Gia_ObjSetRepr( p, i, GIA_VOID );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
    {
        if ( p->pNexts[i] == 0 )
            continue;
        if ( p->pReprs[i].iRepr != GIA_VOID )
            continue;
        // next is set, repr is not set
        for ( iObj = p->pNexts[i]; iObj; iObj = p->pNexts[iObj] )
            p->pReprs[iObj].iRepr = i;
    }
}

Here is the caller graph for this function:

◆ Gia_ManDeriveReprsFromSibls()

void Gia_ManDeriveReprsFromSibls ( Gia_Man_t * p )

extern

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

Synopsis [Given pSibls, derives original representitives and nexts.]

Description []

SideEffects []

SeeAlso []

Definition at line 325 of file giaEquiv.c.

{
    
    int i, iObj;
    assert( !p->pReprs && p->pSibls );
    p->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p) );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
        Gia_ObjSetRepr( p, i, GIA_VOID );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
    {
        if ( p->pSibls[i] == 0 )
            continue;
        if ( p->pReprs[i].iRepr != GIA_VOID )
            continue;
        for ( iObj = p->pSibls[i]; iObj; iObj = p->pSibls[iObj] )
            p->pReprs[iObj].iRepr = i;
    }
    ABC_FREE( p->pNexts );
    p->pNexts = Gia_ManDeriveNexts( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDeriveSolutionOne()

Vec_Int_t * Gia_ManDeriveSolutionOne	(	Gia_Man_t *	p,
		Vec_Wrd_t *	vSims,
		Vec_Wrd_t *	vIsfs,
		Vec_Int_t *	vCands,
		Vec_Int_t *	vSet,
		int	nWords,
		int	Type )

extern

Definition at line 318 of file giaDecs.c.

{
    Vec_Int_t * vRes = NULL;
    Vec_Wrd_t * vTruths = Gia_ManDeriveTruths( p, vSims, vIsfs, vCands, vSet, nWords );
    int nTtWords = Vec_WrdSize(vTruths)/2, nVars = Vec_IntSize(vSet);
    word * pTruth[2] = { Vec_WrdEntryP(vTruths, 0*nTtWords), 
                         Vec_WrdEntryP(vTruths, 1*nTtWords) };
    if ( Type == 0 )
        vRes = Gia_ManDeriveResub( vTruths, nVars );
    else if ( Type == 1 )
        vRes = Gia_ManDeriveBidec( vTruths, nVars );
    else if ( Type == 2 )
        vRes = Gia_ManDeriveIsop( vTruths, nVars );
    else if ( Type == 3 )
        vRes = Gia_ManDeriveBdd( vTruths, nVars );
    if ( vRes && Gia_ResubVarNum(vRes) <= 6 )
    {
        word Func = Gia_ResubToTruth6( vRes );
        assert( !(Func &  pTruth[0][0]) );
        assert( !(pTruth[1][0] & ~Func) );   
    }
    Vec_WrdFree( vTruths );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDetectSeqSignals()

void Gia_ManDetectSeqSignals	(	Gia_Man_t *	p,
		int	fSetReset,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 130 of file giaEnable.c.

{
    Vec_Int_t * vSuper;
    Gia_Obj_t * pFlop, * pObjC, * pObj0, * pObj1, * pNode, * pTemp;
    int i, k, Ent, * pSets, * pResets, * pEnables;
    int nHaveSetReset = 0, nHaveEnable = 0;
    assert( Gia_ManRegNum(p) > 0 );
    pSets    = ABC_CALLOC( int, Gia_ManObjNum(p) );
    pResets  = ABC_CALLOC( int, Gia_ManObjNum(p) );
    pEnables = ABC_CALLOC( int, Gia_ManObjNum(p) );
    vSuper   = Vec_IntAlloc( 100 );
    Gia_ManForEachRi( p, pFlop, i )
    {
        pNode = Gia_ObjFanin0(pFlop);
        if ( !Gia_ObjIsAnd(pNode) )
            continue;
        // detect sets/resets
        Gia_CollectSuper( p, pNode, vSuper );
        if ( Gia_ObjFaninC0(pFlop) )
            Vec_IntForEachEntry( vSuper, Ent, k )
                pSets[Ent]++;
        else
            Vec_IntForEachEntry( vSuper, Ent, k )
                pResets[Ent]++;
        // detect enables
        if ( !Gia_ObjIsMuxType(pNode) )
            continue;
        pObjC = Gia_ObjRecognizeMux( pNode, &pObj0, &pObj1 );
        pTemp = Gia_ObjRiToRo( p, pFlop );
        if ( Gia_Regular(pObj0) != pTemp && Gia_Regular(pObj1) != pTemp )
            continue;
        if ( !Gia_ObjFaninC0(pFlop) )
        {
            pObj0 = Gia_Not(pObj0);
            pObj1 = Gia_Not(pObj1);
        }
        if ( Gia_IsComplement(pObjC) )
        {
            pObjC = Gia_Not(pObjC);
            pTemp = pObj0;
            pObj0 = pObj1;
            pObj1 = pTemp;
        }
        // detect controls
//        Gia_CollectSuper( p, pObjC, vSuper );
//        Vec_IntForEachEntry( vSuper, Ent, k )
//            pEnables[Ent]++;
        pEnables[Gia_ObjId(p, pObjC)]++;
        nHaveEnable++;
    }
    Gia_ManForEachRi( p, pFlop, i )
    {
        pNode = Gia_ObjFanin0(pFlop);
        if ( !Gia_ObjIsAnd(pNode) )
            continue;
        // detect sets/resets
        Gia_CollectSuper( p, pNode, vSuper );
        Vec_IntForEachEntry( vSuper, Ent, k )
            if ( pSets[Ent] > 1 || pResets[Ent] > 1 )
            {
                nHaveSetReset++;
                break;
            }
    }
    Vec_IntFree( vSuper );
    ABC_FREE( p->pRefs );
    Gia_ManCreateRefs( p );
    if ( fVerbose )
    {
        printf( "Flops with set/reset = %6d. Flops with enable = %6d.\n", nHaveSetReset, nHaveEnable );
        if ( fSetReset )
        {
            Gia_ManPrintSignals( p, pSets, "Set signals" );
            Gia_ManPrintSignals( p, pResets, "Reset signals" );
        }
        Gia_ManPrintSignals( p, pEnables, "Enable signals" );
    }
    ABC_FREE( p->pRefs );
    ABC_FREE( pSets );
    ABC_FREE( pResets );
    ABC_FREE( pEnables );
}

Here is the call graph for this function:

◆ Gia_ManDumpVerilog()

void Gia_ManDumpVerilog	(	Gia_Man_t *	p,
		char *	pFileName,
		Vec_Int_t *	vObjs,
		int	fVerBufs,
		int	fInter,
		int	fInterComb,
		int	fAssign,
		int	fReverse )

extern

Definition at line 1415 of file giaMan.c.

{
    if ( fInterComb ) 
    {
        if ( fAssign ) {
            extern void Gia_ManDumpInterfaceAssign( Gia_Man_t * p, char * pFileName );
            Gia_ManDumpInterfaceAssign( p, pFileName );
        }
        else {
            extern void Gia_ManDumpInterface( Gia_Man_t * p, char * pFileName );
            Gia_ManDumpInterface( p, pFileName );
        }
    }
    else
    {
        if ( fAssign ) {
            extern void Gia_ManDumpVerilogNoInterAssign( Gia_Man_t * p, char * pFileName, Vec_Int_t * vObjs, int fVerBufs, int fInter );
            Gia_ManDumpVerilogNoInterAssign( p, pFileName, vObjs, fVerBufs, fInter );
        }
        else {
            extern void Gia_ManDumpVerilogNoInter( Gia_Man_t * p, char * pFileName, Vec_Int_t * vObjs, int fVerBufs, int fInter );
            Gia_ManDumpVerilogNoInter( p, pFileName, vObjs, fVerBufs, fInter );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDumpVerilogNand()

void Gia_ManDumpVerilogNand	(	Gia_Man_t *	p,
		char *	pFileName )

extern

Definition at line 2151 of file giaMan.c.

{
    Gia_Obj_t * pObj;  int i, nPis = Gia_ManPiNum(p);
    int nDigits  = Abc_Base10Log( Gia_ManObjNum(p) );
    int nDigitsI = Abc_Base10Log( Gia_ManPiNum(p) );
    int nDigitsO = Abc_Base10Log( Gia_ManPoNum(p) );
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open output file \"%s\".\n", pFileName );
        return;
    }
    assert( Gia_ManRegNum(p) == 0 );
    fprintf( pFile, "module " );
    Gia_ManDumpModuleName( pFile, p->pName );
    fprintf( pFile, "_wrapper" );
    fprintf( pFile, " ( " );
    if ( p->vNamesIn ) {
        Gia_ManDumpIoList( p, pFile, 0, 0 );
        fprintf( pFile, ", " );
        Gia_ManDumpIoList( p, pFile, 1, 0 );
        fprintf( pFile, " );\n\n" );
        Gia_ManDumpIoRanges( p, pFile, 0 );
        Gia_ManDumpIoRanges( p, pFile, 1 );
    }
    else {
        fprintf( pFile, "\n  " );        
        Gia_ManForEachPi( p, pObj, i )
            fprintf( pFile, "%s, ", Gia_ObjGetDumpName(NULL, 'x', i, nDigitsI) );
        fprintf( pFile, "\n  " );        
        Gia_ManForEachPo( p, pObj, i )
            fprintf( pFile, "%s%s ", Gia_ObjGetDumpName(NULL, 'z', i, nDigitsO), i < Gia_ManPoNum(p)-1 ? ",":"" );
        fprintf( pFile, "\n);\n\n" );
        fprintf( pFile, "  input" );
        Gia_ManForEachPi( p, pObj, i )
            fprintf( pFile, " %s%s", Gia_ObjGetDumpName(NULL, 'x', i, nDigitsI), i < Gia_ManPiNum(p)-1 ? ",":"" );
        fprintf( pFile, ";\n" );
        fprintf( pFile, "  output" );
        Gia_ManForEachPo( p, pObj, i )
            fprintf( pFile, " %s%s", Gia_ObjGetDumpName(NULL, 'z', i, nDigitsO), i < Gia_ManPoNum(p)-1 ? ",":"" );
        fprintf( pFile, ";\n" );
    }
    fprintf( pFile, "\n" );
    Gia_ManForEachPi( p, pObj, i )
        fprintf( pFile, "  wire n%0*d = %s;\n", nDigits, i+1, p->vNamesIn ? (char *)Vec_PtrEntry(p->vNamesIn, i) : Gia_ObjGetDumpName(p->vNamesIn, 'x', i, nDigitsI) );
    fprintf( pFile, "\n" );    
    Gia_ManForEachAnd( p, pObj, i )
    {
        fprintf( pFile, "  wire n%0*d = ~(", nDigits, i );
        Gia_ManDumpNandLit( pFile, nPis, Gia_ObjFaninLit0(pObj, i), nDigits );
        fprintf( pFile, " & " );
        Gia_ManDumpNandLit( pFile, nPis, Gia_ObjFaninLit1(pObj, i), nDigits );
        fprintf( pFile, ");\n" );
    }
    fprintf( pFile, "\n" );
    Gia_ManForEachPo( p, pObj, i )
    {
        fprintf( pFile, "  assign %s = ", p->vNamesOut ? (char *)Vec_PtrEntry(p->vNamesOut, i) : Gia_ObjGetDumpName(p->vNamesOut, 'z', i, nDigitsO) );
        Gia_ManDumpNandLit( pFile, nPis, Gia_ObjFaninLit0p(p, pObj), nDigits );
        fprintf( pFile, ";\n" );
    }   
    fprintf( pFile, "\nendmodule\n\n" );
    fclose( pFile );
}

Here is the call graph for this function:

◆ Gia_ManDup()

Gia_Man_t * Gia_ManDup ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 720 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    if ( Gia_ManHasChoices(p) )
        pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
        {
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
            if ( Gia_ObjSibl(p, Gia_ObjId(p, pObj)) )
                pNew->pSibls[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var(Gia_ObjSiblObj(p, Gia_ObjId(p, pObj))->Value);  
        }
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    if ( p->pCexSeq )
        pNew->pCexSeq = Abc_CexDup( p->pCexSeq, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDup2()

Gia_Man_t * Gia_ManDup2	(	Gia_Man_t *	p1,
		Gia_Man_t *	p2 )

extern

Definition at line 751 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManCiNum(p1) == Gia_ManCiNum(p2) );
    assert( Gia_ManCoNum(p1) == Gia_ManCoNum(p2) );
    pNew = Gia_ManStart( Gia_ManObjNum(p1) + Gia_ManObjNum(p2) );
    Gia_ManHashStart( pNew );
    Gia_ManConst0(p1)->Value = 0;
    Gia_ManConst0(p2)->Value = 0;
    Gia_ManForEachCi( p1, pObj, i )
        pObj->Value = Gia_ManCi(p2, i)->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p1, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachAnd( p2, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p1, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachCo( p2, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p1) );
    Gia_ManHashStop( pNew );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupAndCones()

Gia_Man_t * Gia_ManDupAndCones	(	Gia_Man_t *	p,
		int *	pAnds,
		int	nAnds,
		int	fTrimPis )

extern

Definition at line 3941 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Vec_Ptr_t * vLeaves, * vNodes, * vRoots;
    Gia_Obj_t * pObj;
    int i;
 
    // collect initial POs
    vLeaves = Vec_PtrAlloc( 100 );
    vNodes = Vec_PtrAlloc( 100 );
    vRoots = Vec_PtrAlloc( 100 );
    for ( i = 0; i < nAnds; i++ )
//        Vec_PtrPush( vRoots, Gia_ManPo(p, pPos[i]) );
        Vec_PtrPush( vRoots, Gia_ManObj(p, pAnds[i]) );
 
    // mark internal nodes
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
        Gia_ManDupCones_rec( p, pObj, vLeaves, vNodes, vRoots );
    Vec_PtrSort( vLeaves, (int (*)(const void *, const void *))Gia_ObjCompareByCioId );
 
    // start the new manager
//    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Vec_PtrSize(vLeaves) + Vec_PtrSize(vNodes) + Vec_PtrSize(vRoots) + 1);
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    // map the constant node
    Gia_ManConst0(p)->Value = 0;
    // create PIs
    if ( fTrimPis )
    {
        Vec_PtrForEachEntry( Gia_Obj_t *, vLeaves, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
    }
    else
    {
        Gia_ManForEachPi( p, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
    }
    // create LOs
//    Vec_PtrForEachEntryStart( Gia_Obj_t *, vRoots, pObj, i, nPos )
//        Gia_ObjRiToRo(p, pObj)->Value = Gia_ManAppendCi( pNew );
    // create internal nodes
    Vec_PtrForEachEntry( Gia_Obj_t *, vNodes, pObj, i )
        if ( Gia_ObjIsMux(p, pObj) )
            pObj->Value = Gia_ManAppendMux( pNew, Gia_ObjFanin2Copy(p, pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsXor(pObj) )
            pObj->Value = Gia_ManAppendXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else 
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create COs
    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
//        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Gia_ManAppendCo( pNew, pObj->Value );
    // finalize
//    Gia_ManSetRegNum( pNew, Vec_PtrSize(vRoots)-nPos );
    Gia_ManSetRegNum( pNew, 0 );
    Vec_PtrFree( vLeaves );
    Vec_PtrFree( vNodes );
    Vec_PtrFree( vRoots );
    return pNew;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupAndConesLimit()

Gia_Man_t * Gia_ManDupAndConesLimit	(	Gia_Man_t *	p,
		int *	pAnds,
		int	nAnds,
		int	Level )

extern

Definition at line 4021 of file giaDup.c.

{
    Gia_Man_t * pNew;
    int i;
    pNew = Gia_ManStart( 1000 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManLevelNum( p );
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    for ( i = 0; i < nAnds; i++ )
        Gia_ManDupAndConesLimit_rec( pNew, p, pAnds[i], Level );
    for ( i = 0; i < nAnds; i++ )
        Gia_ManAppendCo( pNew, Gia_ManObj(p, pAnds[i])->Value );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupAndConesLimit2()

Gia_Man_t * Gia_ManDupAndConesLimit2	(	Gia_Man_t *	p,
		int *	pAnds,
		int	nAnds,
		int	Level )

extern

Definition at line 4054 of file giaDup.c.

{
    Gia_Man_t * pNew;
    int i;
    pNew = Gia_ManStart( 1000 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    for ( i = 0; i < nAnds; i++ )
        Gia_ManDupAndConesLimit2_rec( pNew, p, pAnds[i], Level );
    for ( i = 0; i < nAnds; i++ )
        Gia_ManAppendCo( pNew, Gia_ManObj(p, pAnds[i])->Value );
    return pNew;
 
}

Here is the call graph for this function:

◆ Gia_ManDupAndOr()

Gia_Man_t * Gia_ManDupAndOr	(	Gia_Man_t *	p,
		int	nOuts,
		int	fUseOr,
		int	fCompl )

extern

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

Synopsis [Computes the AND of all POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 3216 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, iResult;
    assert( Gia_ManRegNum(p) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    if ( fUseOr ) // construct OR of all POs
    {
        iResult = 0;
        Gia_ManForEachPo( p, pObj, i )
            iResult = Gia_ManHashOr( pNew, iResult, Gia_ObjFanin0Copy(pObj) );
    }
    else // construct AND of all POs
    {
        iResult = 1;
        Gia_ManForEachPo( p, pObj, i )
            iResult = Gia_ManHashAnd( pNew, iResult, Gia_ObjFanin0Copy(pObj) );
    }
    iResult = Abc_LitNotCond( iResult, (int)(fCompl > 0) );
//    Gia_ManForEachPo( p, pObj, i )
//        pObj->Value = Gia_ManAppendCo( pNew, iResult );
    for ( i = 0; i < nOuts; i++ )
        Gia_ManAppendCo( pNew, iResult );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupAppend()

void Gia_ManDupAppend	(	Gia_Man_t *	pNew,
		Gia_Man_t *	pTwo )

extern

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

Synopsis [Appends second AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1137 of file giaDup.c.

{
    Gia_Obj_t * pObj;
    int i;
    if ( pNew->nRegs > 0 )
        pNew->nRegs = 0;
    if ( Vec_IntSize(&pNew->vHTable) == 0 )
        Gia_ManHashStart( pNew );
    Gia_ManConst0(pTwo)->Value = 0;
    Gia_ManForEachObj1( pTwo, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
}

Here is the call graph for this function:

◆ Gia_ManDupAppendCones()

Gia_Man_t * Gia_ManDupAppendCones	(	Gia_Man_t *	p,
		Gia_Man_t **	ppCones,
		int	nCones,
		int	fOnlyRegs )

extern

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

Synopsis [Appends logic cones as additional property outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1305 of file giaDup.c.

{
    Gia_Man_t * pNew, * pOne;
    Gia_Obj_t * pObj;
    int i, k;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    for ( k = 0; k < nCones; k++ )
    {
        pOne = ppCones[k];
        assert( Gia_ManPoNum(pOne) == 1 );
        assert( Gia_ManRegNum(pOne) == 0 );
        if ( fOnlyRegs )
            assert( Gia_ManPiNum(pOne) == Gia_ManRegNum(p) );
        else
            assert( Gia_ManPiNum(pOne) == Gia_ManCiNum(p) );
        Gia_ManConst0(pOne)->Value = 0;
        Gia_ManForEachPi( pOne, pObj, i )
            pObj->Value = Gia_ManCiLit( pNew, fOnlyRegs ? Gia_ManPiNum(p) + i : i );
        Gia_ManForEachAnd( pOne, pObj, i )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        Gia_ManForEachPo( pOne, pObj, i )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pOne = pNew );
    Gia_ManStop( pOne );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupAppendNew()

Gia_Man_t * Gia_ManDupAppendNew	(	Gia_Man_t *	pOne,
		Gia_Man_t *	pTwo )

extern

Definition at line 1174 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(pOne) + Gia_ManObjNum(pTwo) );
    pNew->pName = Abc_UtilStrsav( pOne->pName );
    pNew->pSpec = Abc_UtilStrsav( pOne->pSpec );
    Gia_ManHashAlloc( pNew );
    Gia_ManConst0(pOne)->Value = 0;
    Gia_ManForEachObj1( pOne, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
    }
    Gia_ManConst0(pTwo)->Value = 0;
    Gia_ManForEachObj1( pTwo, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsPi(pTwo, pObj) )
            pObj->Value = Gia_ManPi(pOne, Gia_ObjCioId(pObj))->Value;
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
    }
    Gia_ManHashStop( pNew );
    // primary outputs
    Gia_ManForEachPo( pOne, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachPo( pTwo, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    // flop inputs
    Gia_ManForEachRi( pOne, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachRi( pTwo, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(pOne) + Gia_ManRegNum(pTwo) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupAppendShare()

void Gia_ManDupAppendShare	(	Gia_Man_t *	p,
		Gia_Man_t *	pTwo )

extern

Definition at line 1156 of file giaDup.c.

{
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(pTwo) );
    if ( Vec_IntSize(&pNew->vHTable) == 0 )
        Gia_ManHashStart( pNew );
    Gia_ManConst0(pTwo)->Value = 0;
    Gia_ManForEachObj1( pTwo, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_Obj2Lit( pNew, Gia_ManCi( pNew, Gia_ObjCioId(pObj) ) );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupBlock()

Gia_Man_t * Gia_ManDupBlock	(	Gia_Man_t *	p,
		int	nBlock )

extern

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

Synopsis [Reduce bit-width of GIA assuming it is Boolean.]

Description []

SideEffects []

SeeAlso []

Definition at line 1976 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj; int i;
    assert( Gia_ManCiNum(p) % nBlock == 0 );
    assert( Gia_ManCoNum(p) % nBlock == 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, pObj, i )
        pObj->Value = (i % nBlock == 0) ? Gia_ManAppendCi(pNew) : 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        if ( i % nBlock == 0 )
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p)/nBlock );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupChoicesAdd()

void Gia_ManDupChoicesAdd	(	Gia_ChMan_t *	pMan,
		Gia_Man_t *	pGia )

extern

Definition at line 6411 of file giaDup.c.

{
    Gia_Obj_t * pObj; int i;
    assert( Gia_ManCiNum(p->pNew)   == Gia_ManCiNum(pGia) );
    assert( !p->vCoLits || Vec_IntSize(p->vCoLits) == Gia_ManCoNum(pGia) );
    assert( Gia_ManRegNum(p->pNew)  == Gia_ManRegNum(pGia) );    
    Gia_ManFillValue( pGia );
    Gia_ManForEachCi( pGia, pObj, i )
        pObj->Value = Gia_ManCiLit( p->pNew, i );
    Gia_ManForEachAnd( pGia, pObj, i )
        Gia_ManDupChoicesNode( p, pGia, i );
    assert( Vec_IntSize(p->vObj2Tt) == Gia_ManObjNum(p->pNew) );
    assert( Vec_IntSize(p->vTt2Obj) == Vec_MemEntryNum(p->vTtMem) );   
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupChoicesFinish()

Gia_Man_t * Gia_ManDupChoicesFinish ( Gia_ChMan_t * pMan )

extern

Definition at line 6464 of file giaDup.c.

{
    Gia_Man_t * pTemp, * pNew = p->pNew; int i, iLit;
    p->vSibls = Gia_ManDupChoicesCreateSibls( p );
    p->pNew->pSibls = Vec_IntReleaseArray( p->vSibls );
    Vec_IntForEachEntry( p->vCoLits, iLit, i )
        Gia_ManAppendCo( p->pNew, iLit );
    Vec_MemFree( p->vTtMem );
    Vec_IntFree( p->vSibls );
    Vec_IntFree( p->vTt2Obj );
    Vec_IntFree( p->vObj2Tt );
    Vec_IntFree( p->vCoLits );
    ABC_FREE( p->pTruth );
    ABC_FREE( p );
    pTemp = Gia_ManReorderChoices( pNew );
    Gia_ManStop( pNew );
    return pTemp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupChoicesStart()

Gia_ChMan_t * Gia_ManDupChoicesStart ( Gia_Man_t * pGia )

extern

Definition at line 6425 of file giaDup.c.

{
    Gia_ChMan_t * p = ABC_CALLOC( Gia_ChMan_t, 1 );
    p->pNew = Gia_ManStart( 10*Gia_ManObjNum(pGia) );
    p->pNew->pName = Abc_UtilStrsav( pGia->pName );
    p->pNew->pSpec = Abc_UtilStrsav( pGia->pSpec );
    p->vTtMem = Vec_MemAllocWithTTs( Gia_ManCiNum(pGia) );
    p->vTt2Obj = Vec_IntStartNatural( 1 + Gia_ManCiNum(pGia) );
    p->vObj2Tt = Vec_IntAlloc( 10*Gia_ManObjNum(pGia) );
    p->nWords = Abc_TtWordNum( Gia_ManCiNum(pGia) );
    p->pTruth = ABC_CALLOC( word, p->nWords );
    Gia_Obj_t * pObj; int i;
    for ( i = 0; i <= Gia_ManCiNum(pGia); i++ )
        Vec_IntPush( p->vObj2Tt, Abc_Var2Lit(i, 0) );
    Gia_ManForEachCi( pGia, pObj, i )
        Gia_ManAppendCi(p->pNew);
    Gia_ManSetRegNum( p->pNew, Gia_ManRegNum(pGia) );
    Gia_ManHashStart( p->pNew );
    Gia_ManDupChoicesAdd( p, pGia );
    p->vCoLits = Vec_IntAlloc( Gia_ManCoNum(pGia) );
    Gia_ManForEachCo( pGia, pObj, i )
        Vec_IntPush( p->vCoLits, Gia_ObjFanin0Copy(pObj) );
    return p;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupCof()

Gia_Man_t * Gia_ManDupCof	(	Gia_Man_t *	p,
		int	iVar )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 862 of file giaCof.c.

{
    Gia_Man_t * pNew, * pTemp;
    pNew = Gia_ManDupCofInt( p, iVar );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupCofactorObj()

Gia_Man_t * Gia_ManDupCofactorObj	(	Gia_Man_t *	p,
		int	iObj,
		int	Value )

extern

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

Synopsis [Cofactors w.r.t. an internal node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1935 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, iObjValue = -1;
    assert( Gia_ManRegNum(p) == 0 );
    assert( iObj > 0 && iObj < Gia_ManObjNum(p) );
    assert( Gia_ObjIsCand(Gia_ManObj(p, iObj)) );
    assert( Value == 0 || Value == 1 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashAnd(pNew, Gia_ObjFanin0Copy(pObj), iObjValue) );
        if ( i == iObj )
            iObjValue = Abc_LitNotCond(pObj->Value, !Value), pObj->Value = Value;
    }
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupCofactorVar()

Gia_Man_t * Gia_ManDupCofactorVar	(	Gia_Man_t *	p,
		int	iVar,
		int	Value )

extern

Definition at line 1861 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
    assert( Value == 0 || Value == 1 );
    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, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManPi( p, iVar )->Value = Value; // modification!
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupCofactorVar_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew->nConstrs = p->nConstrs;
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupCofAll()

Gia_Man_t * Gia_ManDupCofAll	(	Gia_Man_t *	p,
		int	nFanLim,
		int	fVerbose )

extern

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

Synopsis [Cofactors all variables whose fanout is higher than this.]

Description []

SideEffects []

SeeAlso []

Definition at line 987 of file giaCof.c.

{
    Gia_Man_t * pNew;
    Vec_Int_t * vSigs = Gia_ManCofVars( p, nFanLim );
    pNew = Gia_ManDupCofAllInt( p, vSigs, fVerbose );
    Vec_IntFree( vSigs );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupCofAllInt()

Gia_Man_t * Gia_ManDupCofAllInt	(	Gia_Man_t *	p,
		Vec_Int_t *	vSigs,
		int	fVerbose )

extern

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

Synopsis [Cofactors selected variables (should be in reverse topo order).]

Description []

SideEffects []

SeeAlso []

Definition at line 936 of file giaCof.c.

{
    Vec_Int_t * vSigsNew, * vTemp;
    Gia_Man_t * pAig, * pCof, * pNew;
    int iVar;
    if ( fVerbose )
    { 
        printf( "Cofactoring %d signals.\n", Vec_IntSize(vSigs) );
        Gia_ManPrintStats( p, NULL );
    }
    if ( Vec_IntSize( vSigs ) > 200 )
    {
        printf( "Too many signals to cofactor.\n" );
        return NULL;
    }
    pAig = Gia_ManDup( p );
    vSigsNew = Vec_IntDup( vSigs );
    while ( Vec_IntSize(vSigsNew) > 0 )
    {
        Vec_IntSort( vSigsNew, 0 );
        iVar = Vec_IntPop( vSigsNew );
//        Gia_ManCreateRefs( pAig );
//        printf( "ref count = %d\n", Gia_ObjRefNum( pAig, Gia_ManObj(pAig, iVar) ) );
//        ABC_FREE( pAig->pRefs );
        pCof = Gia_ManDupCofInt( pAig, iVar );
        pNew = Gia_ManCleanup( pCof );
        vSigsNew = Gia_ManTransfer( pAig, pCof, pNew, vTemp = vSigsNew );
        Vec_IntFree( vTemp );
        Gia_ManStop( pAig );
        Gia_ManStop( pCof );
        pAig = pNew;
        if ( fVerbose )
            printf( "Cofactored variable %d.\n", iVar );
        if ( fVerbose )
            Gia_ManPrintStats( pAig, NULL );
    }
    Vec_IntFree( vSigsNew );
    return pAig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupCollapse()

Gia_Man_t * Gia_ManDupCollapse	(	Gia_Man_t *	p,
		Gia_Man_t *	pBoxes,
		Vec_Int_t *	vBoxPres,
		int	fSeq )

extern

Definition at line 802 of file giaTim.c.

{
    // this procedure assumes that sequential AIG with boxes is unshuffled to have valid boxes
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pObjBox;
    int i, k, curCi, curCo, nBBins = 0, nBBouts = 0, nNewPis = 0;
    assert( !fSeq || p->vRegClasses );
    //assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManCiNum(p) == Tim_ManPiNum(pManTime) + Gia_ManCoNum(pBoxes) );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    if ( Gia_ManHasChoices(p) )
        pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManHashAlloc( pNew );
    // copy const and real PIs
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
    {
        pObj = Gia_ManCi( p, i );
        pObj->Value = Gia_ManAppendCi(pNew);
        Gia_ObjSetTravIdCurrent( p, pObj );
    }
    // create logic for each box
    curCi = Tim_ManPiNum(pManTime);
    curCo = 0;
    for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
    {
        // clean boxes
        Gia_ManIncrementTravId( pBoxes );
        Gia_ObjSetTravIdCurrent( pBoxes, Gia_ManConst0(pBoxes) );
        Gia_ManConst0(pBoxes)->Value = 0;
        // add internal nodes
        //printf( "%d ", Tim_ManBoxIsBlack(pManTime, i) );
        if ( Tim_ManBoxIsBlack(pManTime, i) )
        {
            int fSkip = (vBoxPres != NULL && !Vec_IntEntry(vBoxPres, i));
            for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
            {
                pObj = Gia_ManCo( p, curCo + k );
                Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew );
                pObj->Value = fSkip ? -1 : Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
                nBBouts++;
            }
            for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
            {
                pObj = Gia_ManCi( p, curCi + k );
                pObj->Value = fSkip ? 0 : Gia_ManAppendCi(pNew);
                Gia_ObjSetTravIdCurrent( p, pObj );
                nBBins++;
                nNewPis += !fSkip;
            }
        }
        else
        {
            for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
            {
                // build logic
                pObj = Gia_ManCo( p, curCo + k );
                Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew );
                // transfer to the PI
                pObjBox = Gia_ManCi( pBoxes, k );
                pObjBox->Value = Gia_ObjFanin0Copy(pObj);
                Gia_ObjSetTravIdCurrent( pBoxes, pObjBox );
            }
            for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
            {
                // build logic
                pObjBox = Gia_ManCo( pBoxes, curCi - Tim_ManPiNum(pManTime) + k );
                Gia_ManDupCollapse_rec( pBoxes, Gia_ObjFanin0(pObjBox), pNew );
                // transfer to the PI
                pObj = Gia_ManCi( p, curCi + k );
                pObj->Value = Gia_ObjFanin0Copy(pObjBox);
                Gia_ObjSetTravIdCurrent( p, pObj );
            }
        }
        curCo += Tim_ManBoxInputNum(pManTime, i);
        curCi += Tim_ManBoxOutputNum(pManTime, i);
    }
    //printf( "\n" );
    // add remaining nodes
    for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
    {
        pObj = Gia_ManCo( p, i );
        Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew );
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    curCo += Tim_ManPoNum(pManTime);
    // verify counts
    assert( curCi == Gia_ManCiNum(p) );
    assert( curCo == Gia_ManCoNum(p) );
    Gia_ManSetRegNum( pNew, (fSeq && p->vRegClasses) ? Vec_IntSize(p->vRegClasses) : Gia_ManRegNum(p) );
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManCleanupRemap( p, pTemp );
    Gia_ManStop( pTemp );
    if ( nNewPis )
    {
        pNew = Gia_ManDupMoveLast( pTemp = pNew, Tim_ManPiNum(pManTime)-Gia_ManRegNum(pNew), nNewPis );
        Gia_ManCleanupRemap( p, pTemp );
        Gia_ManStop( pTemp );
    }
/*
    printf( "%d = %d - %d    Diff = %d\n", 
        Tim_ManPoNum(pManTime),   Gia_ManCoNum(pNew),  nBBouts, 
        Tim_ManPoNum(pManTime) - (Gia_ManCoNum(pNew) - nBBouts) );
 
    printf( "%d = %d - %d    Diff = %d\n\n", 
        Tim_ManPiNum(pManTime),   Gia_ManCiNum(pNew),  nBBins, 
        Tim_ManPiNum(pManTime) - (Gia_ManCiNum(pNew) - nBBins) );
*/
    assert( vBoxPres != NULL || Tim_ManPoNum(pManTime) == Gia_ManCoNum(pNew) - nBBouts );
    assert( vBoxPres != NULL || Tim_ManPiNum(pManTime) == Gia_ManCiNum(pNew) - nBBins );
    // implement initial state if given
    if ( fSeq && p->vRegInits && Vec_IntSum(p->vRegInits) )
    {
        char * pInit = ABC_ALLOC( char, Vec_IntSize(p->vRegInits) + 1 );
        Gia_Obj_t * pObj;
        int i;
        assert( Vec_IntSize(p->vRegInits) == Gia_ManRegNum(pNew) );
        Gia_ManForEachRo( pNew, pObj, i )
        {
            if ( Vec_IntEntry(p->vRegInits, i) == 0 )
                pInit[i] = '0';
            else if ( Vec_IntEntry(p->vRegInits, i) == 1 )
                pInit[i] = '1';
            else 
                pInit[i] = 'X';
        }
        pInit[i] = 0;
        pNew = Gia_ManDupZeroUndc( pTemp = pNew, pInit, 0, 0, 1 );
        pNew->nConstrs = pTemp->nConstrs; pTemp->nConstrs = 0;
        Gia_ManStop( pTemp );
        ABC_FREE( pInit );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupConeBack()

int Gia_ManDupConeBack	(	Gia_Man_t *	p,
		Gia_Man_t *	pNew,
		Vec_Int_t *	vCiIds )

extern

Definition at line 2270 of file giaDup.c.

{
    Gia_Obj_t * pObj, * pRoot; int i;
    assert( Gia_ManCiNum(pNew) == Vec_IntSize(vCiIds) );
    Gia_ManFillValue(pNew);
    Gia_ManConst0(pNew)->Value = 0;
    Gia_ManForEachCi( pNew, pObj, i )
        pObj->Value = Gia_Obj2Lit( p, Gia_ManCi(p, Vec_IntEntry(vCiIds, i)) );
    pRoot = Gia_ManCo(pNew, 0);
    Gia_ManDupConeBack_rec( p, pNew, Gia_ObjFanin0(pRoot) );
    return Gia_ObjFanin0Copy(pRoot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupConeBackObjs()

int Gia_ManDupConeBackObjs	(	Gia_Man_t *	p,
		Gia_Man_t *	pNew,
		Vec_Int_t *	vObjs )

extern

Definition at line 2282 of file giaDup.c.

{
    Gia_Obj_t * pObj, * pRoot; int i;
    assert( Gia_ManCiNum(pNew) == Vec_IntSize(vObjs) );
    Gia_ManFillValue(pNew);
    Gia_ManConst0(pNew)->Value = 0;
    Gia_ManForEachCi( pNew, pObj, i )
        pObj->Value = Abc_Var2Lit( Vec_IntEntry(vObjs, i), 0 );
    pRoot = Gia_ManCo(pNew, 0);
    Gia_ManDupConeBack_rec( p, pNew, Gia_ObjFanin0(pRoot) );
    return Gia_ObjFanin0Copy(pRoot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupCones()

Gia_Man_t * Gia_ManDupCones	(	Gia_Man_t *	p,
		int *	pPos,
		int	nPos,
		int	fTrimPis )

extern

Definition at line 3880 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Vec_Ptr_t * vLeaves, * vNodes, * vRoots;
    Gia_Obj_t * pObj;
    int i;
 
    // collect initial POs
    vLeaves = Vec_PtrAlloc( 100 );
    vNodes = Vec_PtrAlloc( 100 );
    vRoots = Vec_PtrAlloc( 100 );
    for ( i = 0; i < nPos; i++ )
        Vec_PtrPush( vRoots, Gia_ManPo(p, pPos[i]) );
 
    // mark internal nodes
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
        Gia_ManDupCones_rec( p, pObj, vLeaves, vNodes, vRoots );
    Vec_PtrSort( vLeaves, (int (*)(const void *, const void *))Gia_ObjCompareByCioId );
 
    // start the new manager
//    Gia_ManFillValue( p );
    pNew = Gia_ManStart( (fTrimPis ? Vec_PtrSize(vLeaves) : Gia_ManCiNum(p)) + Vec_PtrSize(vNodes) + Vec_PtrSize(vRoots) + 1 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    // map the constant node
    Gia_ManConst0(p)->Value = 0;
    // create PIs
    if ( fTrimPis )
    {
        Gia_ManForEachPi( p, pObj, i )
            pObj->Value = ~0;
        Vec_PtrForEachEntry( Gia_Obj_t *, vLeaves, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
    }
    else
    {
        Gia_ManForEachPi( p, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
    }
    // create LOs
    Vec_PtrForEachEntryStart( Gia_Obj_t *, vRoots, pObj, i, nPos )
        Gia_ObjRiToRo(p, pObj)->Value = Gia_ManAppendCi( pNew );
    // create internal nodes
    Vec_PtrForEachEntry( Gia_Obj_t *, vNodes, pObj, i )
        if ( Gia_ObjIsXor(pObj) )
            pObj->Value = Gia_ManAppendXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create COs
    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    // finalize
    Gia_ManSetRegNum( pNew, Vec_PtrSize(vRoots)-nPos );
    Vec_PtrFree( vLeaves );
    Vec_PtrFree( vNodes );
    Vec_PtrFree( vRoots );
    return pNew;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupConeSupp()

Gia_Man_t * Gia_ManDupConeSupp	(	Gia_Man_t *	p,
		int	iLit,
		Vec_Int_t *	vCiIds )

extern

Definition at line 2235 of file giaDup.c.

{
    Gia_Man_t * pNew; int i, iLit0;
    Gia_Obj_t * pObj, * pRoot = Gia_ManObj( p, Abc_Lit2Var(iLit) );
    Vec_Int_t * vObjs = Vec_IntAlloc( 1000 );
    //assert( Gia_ObjIsAnd(pRoot) );
    if ( Vec_IntSize(&p->vCopies) < Gia_ManObjNum(p) )
        Vec_IntFillExtra( &p->vCopies, Gia_ManObjNum(p), -1 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManForEachCiVec( vCiIds, p, pObj, i )
        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), Gia_ManAppendCi(pNew) );
    Gia_ManDupConeSupp_rec( pNew, p, pRoot, vObjs );
    iLit0 = Gia_ObjCopyArray( p, Abc_Lit2Var(iLit) );
    iLit0 = Abc_LitNotCond( iLit0, Abc_LitIsCompl(iLit) );
    Gia_ManAppendCo( pNew, iLit0 );
    Gia_ManForEachCiVec( vCiIds, p, pObj, i )
        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), -1 );
    Gia_ManForEachObjVec( vObjs, p, pObj, i )
        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), -1 );
    Vec_IntFree( vObjs );
    //assert( Vec_IntCountLarger(&p->vCopies, -1) == 0 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupCycled()

Gia_Man_t * Gia_ManDupCycled	(	Gia_Man_t *	pAig,
		Abc_Cex_t *	pCex,
		int	nFrames )

extern

Definition at line 691 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Vec_Bit_t * vInits;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManCleanMark0(p);
    Gia_ManCycle( p, pCex, nFrames );
    vInits = Vec_BitAlloc( Gia_ManRegNum(p) );
    Gia_ManForEachRo( p, pObj, i )
        Vec_BitPush( vInits, pObj->fMark0 );
    pNew = Gia_ManDupFlip( p, Vec_BitArray(vInits) );
    Vec_BitFree( vInits );
    Gia_ManCleanMark0(p);
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupDemiter()

Gia_Man_t * Gia_ManDupDemiter	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis [Decomposes the miter outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 4675 of file giaDup.c.

{
    Vec_Int_t * vSuper;
    Vec_Ptr_t * vSuperPtr;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pObjPo;
    int i, iLit;
    assert( Gia_ManPoNum(p) == 1 );
    // decompose
    pObjPo = Gia_ManPo( p, 0 );
    vSuper = Vec_IntAlloc( 100 );
    Gia_ManDupWithConstrCollectAnd_rec( p, Gia_ObjFanin0(pObjPo), vSuper, 1 );
    assert( Vec_IntSize(vSuper) > 1 );
    // report the result
    printf( "The miter is %s-decomposable into %d parts.\n", Gia_ObjFaninC0(pObjPo) ? "OR":"AND", Vec_IntSize(vSuper) );
    // create levels
    Gia_ManLevelNum( p );
    Vec_IntForEachEntry( vSuper, iLit, i )
        Gia_ManObj(p, Abc_Lit2Var(iLit))->Value = Gia_ObjLevelId(p, Abc_Lit2Var(iLit));
    // create pointer array
    vSuperPtr = Vec_PtrAlloc( Vec_IntSize(vSuper) );
    Vec_IntForEachEntry( vSuper, iLit, i )
        Vec_PtrPush( vSuperPtr, Gia_Lit2Obj(p, iLit) );
    Vec_PtrSort( vSuperPtr, (int (*)(const void *, const void *))Gia_ManSortByValue );
    // create new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create the outputs
    Vec_PtrForEachEntry( Gia_Obj_t *, vSuperPtr, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjLitCopy(p, Gia_Obj2Lit(p, pObj)) ^ Gia_ObjFaninC0(pObjPo) );
    Gia_ManForEachRi( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    // rehash
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Vec_IntFree( vSuper );
    Vec_PtrFree( vSuperPtr );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupDfs()

Gia_Man_t * Gia_ManDupDfs ( Gia_Man_t * p )

extern

Definition at line 1748 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    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, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew->nConstrs = p->nConstrs;
    if ( p->pCexSeq )
        pNew->pCexSeq = Abc_CexDup( p->pCexSeq, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupDfsCiMap()

Gia_Man_t * Gia_ManDupDfsCiMap	(	Gia_Man_t *	p,
		int *	pCi2Lit,
		Vec_Int_t *	vLits )

extern

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 2708 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
    {
        pObj->Value = Gia_ManAppendCi(pNew);
        if ( ~pCi2Lit[i] )
            pObj->Value = Abc_LitNotCond( Gia_ManObj(p, Abc_Lit2Var(pCi2Lit[i]))->Value, Abc_LitIsCompl(pCi2Lit[i]) );
    }
    Gia_ManHashAlloc( pNew );
    if ( vLits )
    {
        int iLit, iLitRes;
        Vec_IntForEachEntry( vLits, iLit, i )
        {
            iLitRes = Gia_ManDupDfs2_rec( pNew, p, Gia_ManObj(p, Abc_Lit2Var(iLit)) );
            Gia_ManAppendCo( pNew, Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iLit)) );
        }
    }
    else
    {
        Gia_ManForEachCo( p, pObj, i )
        {
            Gia_ManDupDfs2_rec( pNew, p, Gia_ObjFanin0(pObj) );
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        }
    }
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupDfsClasses()

Gia_Man_t * Gia_ManDupDfsClasses ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 2795 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( p->pReprsOld != NULL );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupDfs_rec( pNew, p, pObj );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupDfsCone()

Gia_Man_t * Gia_ManDupDfsCone	(	Gia_Man_t *	p,
		Gia_Obj_t *	pRoot )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 2188 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ObjIsCo(pRoot) );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin0(pRoot) );
    Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pRoot) );
    Gia_ManSetRegNum( pNew, 0 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupDfsLitArray()

Gia_Man_t * Gia_ManDupDfsLitArray	(	Gia_Man_t *	p,
		Vec_Int_t *	vLits )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 2346 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i, iLit, iLitRes;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Vec_IntForEachEntry( vLits, iLit, i )
    {
        iLitRes = Gia_ManDupDfs2_rec( pNew, p, Gia_ManObj(p, Abc_Lit2Var(iLit)) );
        Gia_ManAppendCo( pNew, Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iLit)) );
    }
    Gia_ManSetRegNum( pNew, 0 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupDfsNode()

Gia_Man_t * Gia_ManDupDfsNode	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

Definition at line 2321 of file giaDup.c.

{
    Gia_Man_t * pNew;
    assert( Gia_ObjIsAnd(pRoot) );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManDupDfs3_rec( pNew, p, pRoot );
    Gia_ManAppendCo( pNew, pRoot->Value );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupDfsOnePo()

Gia_Man_t * Gia_ManDupDfsOnePo	(	Gia_Man_t *	p,
		int	iPo )

extern

Definition at line 1770 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( iPo >= 0 && iPo < Gia_ManPoNum(p) );
    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, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachCo( p, pObj, i )
        if ( !Gia_ObjIsPo(p, pObj) || i == iPo )
            Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        if ( !Gia_ObjIsPo(p, pObj) || i == iPo )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupDfsRehash()

Gia_Man_t * Gia_ManDupDfsRehash ( Gia_Man_t * p )

extern

Definition at line 1815 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    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, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupDfsRehash_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew->nConstrs = p->nConstrs;
    if ( p->pCexSeq )
        pNew->pCexSeq = Abc_CexDup( p->pCexSeq, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupDfsSkip()

Gia_Man_t * Gia_ManDupDfsSkip ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 2158 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachCo( p, pObj, i )
        if ( pObj->fMark1 == 0 )
            Gia_ManDupDfs_rec( pNew, p, pObj );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupExist()

Gia_Man_t * Gia_ManDupExist	(	Gia_Man_t *	p,
		int	iVar )

extern

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

Synopsis [Existentially quantified given variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 2012 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
    assert( Gia_ManPoNum(p) == 1 );
    assert( Gia_ManRegNum(p) == 0 );
    Gia_ManFillValue( p );
    // find the cofactoring variable
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    // compute negative cofactor
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 0 );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ObjFanin0Copy(pObj);
    // compute the positive cofactor
    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 1 );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create OR gate
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashOr(pNew, Gia_ObjFanin0Copy(pObj), pObj->Value) );
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupFlip()

Gia_Man_t * Gia_ManDupFlip	(	Gia_Man_t *	p,
		int *	pInitState )

extern

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

Synopsis [Duplicates AIG while complementing the flops.]

Description [The array of initial state contains the init state for each state bit of the flops in the design.]

SideEffects []

SeeAlso []

Definition at line 628 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
        {
            pObj->Value = Gia_ManAppendCi( pNew );
            if ( Gia_ObjCioId(pObj) >= Gia_ManPiNum(p) )
                pObj->Value = Abc_LitNotCond( pObj->Value, Abc_InfoHasBit((unsigned *)pInitState, Gia_ObjCioId(pObj) - Gia_ManPiNum(p)) );
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            pObj->Value = Gia_ObjFanin0Copy(pObj);
            if ( Gia_ObjCioId(pObj) >= Gia_ManPoNum(p) )
                pObj->Value = Abc_LitNotCond( pObj->Value, Abc_InfoHasBit((unsigned *)pInitState, Gia_ObjCioId(pObj) - Gia_ManPoNum(p)) );
            pObj->Value = Gia_ManAppendCo( pNew, pObj->Value );
        }
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupFlopClass()

Gia_Man_t * Gia_ManDupFlopClass	(	Gia_Man_t *	p,
		int	iClass )

extern

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

Synopsis [Duplicates while adding self-loops to the registers.]

Description []

SideEffects []

SeeAlso []

Definition at line 1399 of file giaDup.c.

{
    Gia_Man_t * pNew; 
    Gia_Obj_t * pObj;
    int i, Counter1 = 0, Counter2 = 0;
    assert( p->vFlopClasses != NULL );
    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, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachRo( p, pObj, i )
        if ( Vec_IntEntry(p->vFlopClasses, i) != iClass )
            pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachRo( p, pObj, i )
        if ( Vec_IntEntry(p->vFlopClasses, i) == iClass )
            pObj->Value = Gia_ManAppendCi( pNew ), Counter1++;
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachRi( p, pObj, i )
        if ( Vec_IntEntry(p->vFlopClasses, i) != iClass )
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachRi( p, pObj, i )
        if ( Vec_IntEntry(p->vFlopClasses, i) == iClass )
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ), Counter2++;
    assert( Counter1 == Counter2 );
    Gia_ManSetRegNum( pNew, Counter1 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupFromVecs()

Gia_Man_t * Gia_ManDupFromVecs	(	Gia_Man_t *	p,
		Vec_Int_t *	vCis,
		Vec_Int_t *	vAnds,
		Vec_Int_t *	vCos,
		int	nRegs )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 4176 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    // start the new manager
    pNew = Gia_ManStart( 5000 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    // create constant
    Gia_ManConst0(p)->Value = 0;
    // create PIs
    Gia_ManForEachObjVec( vCis, p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    // create internal nodes
    Gia_ManForEachObjVec( vAnds, p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create ROs
    Gia_ManForEachObjVec( vCos, p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, nRegs );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupHashMapping()

Gia_Man_t * Gia_ManDupHashMapping ( Gia_Man_t * p )

extern

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

Synopsis [Performs hashing for a mapped AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 2772 of file giaIf.c.

{
    Gia_Man_t * pNew; 
    Vec_Int_t * vMapping; 
    Gia_Obj_t * pObj, * pFanin;
    int i, k;
    assert( Gia_ManHasMapping(p) );
    // copy the old manager with hashing
    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_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    // recreate mapping
    vMapping = Vec_IntAlloc( Vec_IntSize(p->vMapping) );
    Vec_IntFill( vMapping, Gia_ManObjNum(p), 0 );
    Gia_ManForEachLut( p, i )
    {
        pObj = Gia_ManObj( p, i );
        Vec_IntWriteEntry( vMapping, Abc_Lit2Var(pObj->Value), Vec_IntSize(vMapping) );
        Vec_IntPush( vMapping, Gia_ObjLutSize(p, i) );
        Gia_LutForEachFaninObj( p, i, pFanin, k )
            Vec_IntPush( vMapping, Abc_Lit2Var(pFanin->Value)  );
        Vec_IntPush( vMapping, Abc_Lit2Var(pObj->Value) );
    }
    pNew->vMapping = vMapping;
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupLastPis()

Gia_Man_t * Gia_ManDupLastPis	(	Gia_Man_t *	p,
		int	nLastPis )

extern

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

Synopsis [Duplicates AIG while putting first PIs, then nodes, then POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 597 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManRegNum(p) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = (i < Gia_ManCiNum(p) - nLastPis) ? ~0 : Gia_ManAppendCi(pNew);
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupLevelized()

Gia_Man_t * Gia_ManDupLevelized ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates the AIG with nodes ordered by level.]

Description []

SideEffects []

SeeAlso []

Definition at line 4135 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i, nLevels = Gia_ManLevelNum( p );
    int * pCounts = ABC_CALLOC( int, nLevels + 1 );
    int * pNodes = ABC_ALLOC( int, Gia_ManAndNum(p) );
    Gia_ManForEachAnd( p, pObj, i )
        pCounts[Gia_ObjLevel(p, pObj)]++;
    for ( i = 1; i <= nLevels; i++ )
        pCounts[i] += pCounts[i-1];
    Gia_ManForEachAnd( p, pObj, i )
        pNodes[pCounts[Gia_ObjLevel(p, pObj)-1]++] = i;
    // duplicate
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    for ( i = 0; i < Gia_ManAndNum(p) && (pObj = Gia_ManObj(p, pNodes[i])); i++ )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    ABC_FREE( pCounts );
    ABC_FREE( pNodes );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupMap()

Gia_Man_t * Gia_ManDupMap	(	Gia_Man_t *	p,
		Vec_Int_t *	vMap )

extern

Definition at line 846 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Vec_IntEntry(vMap, i) >= 0 )
            pObj->Value = Gia_ManObj( p, Vec_IntEntry(vMap, i) )->Value;
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupMarked()

Gia_Man_t * Gia_ManDupMarked ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1444 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i, nRos = 0, nRis = 0;
    int CountMarked = 0;
    Gia_ManForEachObj( p, pObj, i )
        CountMarked += pObj->fMark0;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) - CountMarked );
    if ( p->pMuxes )
        pNew->pMuxes = ABC_CALLOC( unsigned, pNew->nObjsAlloc );
    pNew->nConstrs = p->nConstrs;
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( pObj->fMark0 )
        {
            assert( !Gia_ObjIsBuf(pObj) );
            pObj->fMark0 = 0;
            continue;
        }
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
        {
            if ( Gia_ObjIsXor(pObj) )
                pObj->Value = Gia_ManAppendXorReal( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
            else if ( Gia_ObjIsMux(p, pObj) )
                pObj->Value = Gia_ManAppendMuxReal( pNew, Gia_ObjFanin2Copy(p, pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin0Copy(pObj) );
            else
                pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        }
        else if ( Gia_ObjIsCi(pObj) )
        {
            pObj->Value = Gia_ManAppendCi( pNew );
            nRos += Gia_ObjIsRo(p, pObj);
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
//            Gia_Obj_t * pFanin = Gia_ObjFanin0(pObj);
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
            nRis += Gia_ObjIsRi(p, pObj);
        }
    }
    assert( pNew->nObjsAlloc == pNew->nObjs );
    assert( nRos == nRis );
    Gia_ManSetRegNum( pNew, nRos );
    if ( p->pReprs && p->pNexts )
    {
        Gia_Obj_t * pRepr;
        pNew->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pNew) );
        for ( i = 0; i < Gia_ManObjNum(pNew); i++ )
            Gia_ObjSetRepr( pNew, i, GIA_VOID );
        Gia_ManForEachObj1( p, pObj, i )
        {
            if ( !~pObj->Value )
                continue;
            pRepr = Gia_ObjReprObj( p, i );
            if ( pRepr == NULL )
                continue;
            if ( !~pRepr->Value )
                continue;
            assert( !Gia_ObjIsBuf(pObj) );
            if ( Abc_Lit2Var(pObj->Value) != Abc_Lit2Var(pRepr->Value) )
                Gia_ObjSetRepr( pNew, Abc_Lit2Var(pObj->Value), Abc_Lit2Var(pRepr->Value) ); 
        }
        pNew->pNexts = Gia_ManDeriveNexts( pNew );
    }
    if ( Gia_ManHasChoices(p) )
    {
        Gia_Obj_t * pSibl;
        pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(pNew) );
        Gia_ManForEachObj1( p, pObj, i )
        {
            if ( !~pObj->Value )
                continue;
            pSibl = Gia_ObjSiblObj( p, i );
            if ( pSibl == NULL )
                continue;
            if ( !~pSibl->Value )
                continue;
            assert( !Gia_ObjIsBuf(pObj) );
            assert( Abc_Lit2Var(pObj->Value) > Abc_Lit2Var(pSibl->Value) );
            pNew->pSibls[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var(pSibl->Value);
        }
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupMux()

Gia_Man_t * Gia_ManDupMux	(	int	iVar,
		Gia_Man_t *	pCof1,
		Gia_Man_t *	pCof0 )

extern

Definition at line 1887 of file giaDup.c.

{
    Gia_Man_t * pGia[2] = {pCof0, pCof1};
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, n;
    assert( Gia_ManRegNum(pCof0) == 0 );
    assert( Gia_ManRegNum(pCof1) == 0 );
    assert( Gia_ManCoNum(pCof0) == 1 );
    assert( Gia_ManCoNum(pCof1) == 1 );
    assert( Gia_ManCiNum(pCof1) == Gia_ManCiNum(pCof0) );
    assert( iVar >= 0 && iVar < Gia_ManCiNum(pCof1) );
    pNew = Gia_ManStart( Gia_ManObjNum(pCof1) + Gia_ManObjNum(pCof0) );
    pNew->pName = Abc_UtilStrsav( pCof1->pName );
    pNew->pSpec = Abc_UtilStrsav( pCof1->pSpec );
    Gia_ManHashAlloc( pNew );
    for ( n = 0; n < 2; n++ )
    {
        Gia_ManFillValue( pGia[n] );
        Gia_ManConst0(pGia[n])->Value = 0;
        Gia_ManForEachCi( pGia[n], pObj, i )
            pObj->Value = n ? Gia_ManCi(pGia[0], i)->Value : Gia_ManAppendCi(pNew);
        Gia_ManForEachCo( pGia[n], pObj, i )
            Gia_ManDupCofactorVar_rec( pNew, pGia[n], Gia_ObjFanin0(pObj) );
    }
    Gia_ManForEachCo( pGia[0], pObj, i )
    {
        int Ctrl = Gia_ManCi(pGia[0], iVar)->Value;
        int Lit1 = Gia_ObjFanin0Copy(Gia_ManCo(pGia[1], i));
        int Lit0 = Gia_ObjFanin0Copy(pObj);
        Gia_ManAppendCo( pNew, Gia_ManHashMux( pNew, Ctrl, Lit1, Lit0 ) );
    }
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupMuxes()

Gia_Man_t * Gia_ManDupMuxes	(	Gia_Man_t *	p,
		int	Limit )

extern

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

Synopsis [Derives GIA with MUXes.]

Description [Create MUX if the sum of fanin references does not exceed limit.]

SideEffects []

SeeAlso []

Definition at line 98 of file giaMuxes.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pFan0, * pFan1, * pFanC, * pSiblNew, * pObjNew;
    int i;
    assert( p->pMuxes == NULL );
    assert( Limit >= 0 ); // allows to create AIG with XORs without MUXes
    ABC_FREE( p->pRefs );
    Gia_ManCreateRefs( p ); 
    // start the new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->pMuxes = ABC_CALLOC( unsigned, pNew->nObjsAlloc );
    if ( Gia_ManHasChoices(p) )
        pNew->pSibls = ABC_CALLOC( int, pNew->nObjsAlloc );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashStart( pNew );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( !Gia_ObjIsMuxType(pObj) || Gia_ObjSibl(p, Gia_ObjFaninId0(pObj, i)) || Gia_ObjSibl(p, Gia_ObjFaninId1(pObj, i)) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjRecognizeExor(pObj, &pFan0, &pFan1) )
            pObj->Value = Gia_ManHashXorReal( pNew, Gia_ObjLitCopy(p, Gia_ObjToLit(p, pFan0)), Gia_ObjLitCopy(p, Gia_ObjToLit(p, pFan1)) );
        else if ( Gia_ObjRefNum(p, Gia_ObjFanin0(pObj)) + Gia_ObjRefNum(p, Gia_ObjFanin1(pObj)) > Limit )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else
        {
            pFanC = Gia_ObjRecognizeMux( pObj, &pFan1, &pFan0 );
            pObj->Value = Gia_ManHashMuxReal( pNew, Gia_ObjLitCopy(p, Gia_ObjToLit(p, pFanC)), Gia_ObjLitCopy(p, Gia_ObjToLit(p, pFan1)), Gia_ObjLitCopy(p, Gia_ObjToLit(p, pFan0)) );
        }
        if ( !Gia_ObjSibl(p, i) )
            continue;
        pObjNew  = Gia_ManObj( pNew, Abc_Lit2Var(pObj->Value) );
        pSiblNew = Gia_ManObj( pNew, Abc_Lit2Var(Gia_ObjSiblObj(p, i)->Value) );
        if ( Gia_ObjIsAnd(pObjNew) && Gia_ObjIsAnd(pSiblNew) && Gia_ObjId(pNew, pObjNew) > Gia_ObjId(pNew, pSiblNew) )
            pNew->pSibls[Gia_ObjId(pNew, pObjNew)] = Gia_ObjId(pNew, pSiblNew);
    }
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    // perform cleanup
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupNoBuf()

Gia_Man_t * Gia_ManDupNoBuf ( Gia_Man_t * p )

extern

Definition at line 823 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ObjFanin0Copy(pObj);
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupNoMuxes()

Gia_Man_t * Gia_ManDupNoMuxes	(	Gia_Man_t *	p,
		int	fSkipBufs )

extern

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

Synopsis [Derives GIA without MUXes.]

Description []

SideEffects []

SeeAlso []

Definition at line 228 of file giaMuxes.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( p->pMuxes != NULL || Gia_ManXorNum(p) );
    // start the new manager
    pNew = Gia_ManStart( 5000 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashStart( pNew );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = fSkipBufs ? Gia_ObjFanin0Copy(pObj) : Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsMuxId(p, i) )
            pObj->Value = Gia_ManHashMux( pNew, Gia_ObjFanin2Copy(p, pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsXor(pObj) )
            pObj->Value = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else 
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    }
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    // perform cleanup
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupNormalize()

Gia_Man_t * Gia_ManDupNormalize	(	Gia_Man_t *	p,
		int	fHashMapping )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 139 of file giaTim.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    if ( !Gia_ManIsSeqWithBoxes(p) )
    {
        Gia_ManForEachCi( p, pObj, i )
            pObj->Value = Gia_ManAppendCi(pNew);
    }
    else
    {
        // current CI order:  PIs + FOs + NewCIs
        // desired reorder:   PIs + NewCIs + FOs
        int nCIs = Tim_ManPiNum( (Tim_Man_t *)p->pManTime );
        int nAll = Tim_ManCiNum( (Tim_Man_t *)p->pManTime );
        int nPis = nCIs - Gia_ManRegNum(p);
        assert( nAll == Gia_ManCiNum(p) );
        assert( nPis > 0 );
        // copy PIs first
        for ( i = 0; i < nPis; i++ )
            Gia_ManCi(p, i)->Value = Gia_ManAppendCi(pNew);
       // copy new CIs second
        for ( i = nCIs; i < nAll; i++ )
            Gia_ManCi(p, i)->Value = Gia_ManAppendCi(pNew);
        // copy flops last
        for ( i = nCIs - Gia_ManRegNum(p); i < nCIs; i++ )
            Gia_ManCi(p, i)->Value = Gia_ManAppendCi(pNew);
        printf( "Warning: Shuffled CI order to be correct sequential AIG.\n" );
    }
    if ( fHashMapping ) Gia_ManHashAlloc( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( fHashMapping )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    if ( fHashMapping ) Gia_ManHashStop( pNew );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew->nConstrs = p->nConstrs;
    assert( Gia_ManIsNormalized(pNew) );
    Gia_ManDupRemapEquiv( pNew, p );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupOneHot()

Gia_Man_t * Gia_ManDupOneHot ( Gia_Man_t * p )

extern

Definition at line 4108 of file giaDup.c.

{
    Gia_Man_t * pOneHot, * pNew = Gia_ManDup( p );
    if ( Gia_ManRegNum(pNew) == 0 )
    {
        Abc_Print( 0, "Appending 1-hotness constraints to the PIs.\n" );
        pOneHot = Gia_ManOneHot( 0, Gia_ManCiNum(pNew) );
    }
    else
        pOneHot = Gia_ManOneHot( Gia_ManPiNum(pNew), Gia_ManRegNum(pNew) );
    Gia_ManDupAppendShare( pNew, pOneHot );
    pNew->nConstrs += Gia_ManPoNum(pOneHot);
    Gia_ManStop( pOneHot );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupOntop()

Gia_Man_t * Gia_ManDupOntop	(	Gia_Man_t *	p,
		Gia_Man_t *	p2 )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 2590 of file giaDup.c.

{
    Gia_Man_t * pTemp, * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManPoNum(p) == Gia_ManPiNum(p2) );
    assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManRegNum(p2) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p)+Gia_ManObjNum(p2) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    // dup first AIG
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // dup second AIG
    Gia_ManConst0(p2)->Value = 0;
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManPi(p2, i)->Value = Gia_ObjFanin0Copy(pObj);
    Gia_ManForEachAnd( p2, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p2, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
//    Gia_ManPrintStats( pGiaNew, 0 );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupOrderAiger()

Gia_Man_t * Gia_ManDupOrderAiger ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG while putting first PIs, then nodes, then POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 532 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManDupRemapEquiv( pNew, p );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    assert( Gia_ManIsNormalized(pNew) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupOrderDfs()

Gia_Man_t * Gia_ManDupOrderDfs ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG while putting objects in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 206 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManDupOrderDfs_rec( pNew, p, pObj );
    Gia_ManForEachCi( p, pObj, i )
        if ( !~pObj->Value )
            pObj->Value = Gia_ManAppendCi(pNew);
    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
    Gia_ManDupRemapCis( pNew, p );
    Gia_ManDupRemapEquiv( pNew, p );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupOrderDfsChoices()

Gia_Man_t * Gia_ManDupOrderDfsChoices ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG while putting objects in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 438 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( p->pReprs && p->pNexts );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->pNexts = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachCo( p, pObj, i )
    {
        Gia_ManDupOrderDfsChoices_rec( pNew, p, Gia_ObjFanin0(pObj) );
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
//    Gia_ManDeriveReprs( pNew );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupOrderDfsReverse()

Gia_Man_t * Gia_ManDupOrderDfsReverse	(	Gia_Man_t *	p,
		int	fRevFans,
		int	fRevOuts )

extern

Definition at line 482 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    if ( fRevOuts )
    {
        if ( fRevFans )
            Gia_ManForEachCoReverse( p, pObj, i )
                Gia_ManDupOrderDfs2_rec( pNew, p, Gia_ObjFanin0(pObj) );
        else
            Gia_ManForEachCoReverse( p, pObj, i )
                Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
    }
    else
    {
        if ( fRevFans )
            Gia_ManForEachCo( p, pObj, i )
                Gia_ManDupOrderDfs2_rec( pNew, p, Gia_ObjFanin0(pObj) );
        else
            Gia_ManForEachCo( p, pObj, i )
                Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
    }
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManDupRemapCis( pNew, p );
    Gia_ManDupRemapCos( pNew, p );
    Gia_ManDupRemapEquiv( pNew, p );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupOutputGroup()

Gia_Man_t * Gia_ManDupOutputGroup	(	Gia_Man_t *	p,
		int	iOutStart,
		int	iOutStop )

extern

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

Synopsis [Duplicates AIG while putting objects in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 313 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    for ( i = iOutStart; i < iOutStop; i++ )
    {
        pObj = Gia_ManCo( p, i );
        Gia_ManDupOrderDfs_rec( pNew, p, pObj );
    }
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupOutputVec()

Gia_Man_t * Gia_ManDupOutputVec	(	Gia_Man_t *	p,
		Vec_Int_t *	vOutPres )

extern

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

Synopsis [Duplicates AIG while putting objects in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 342 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManPoNum(p) == Vec_IntSize(vOutPres) );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachPo( p, pObj, i )
        if ( Vec_IntEntry(vOutPres, i) )
            Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        if ( Vec_IntEntry(vOutPres, i) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupPerm()

Gia_Man_t * Gia_ManDupPerm	(	Gia_Man_t *	p,
		Vec_Int_t *	vPiPerm )

extern

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 929 of file giaDup.c.

{
//    Vec_Int_t * vPiPermInv;
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Vec_IntSize(vPiPerm) == Gia_ManPiNum(p) );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
//    vPiPermInv = Vec_IntInvert( vPiPerm, -1 );
    Gia_ManForEachPi( p, pObj, i )
//        Gia_ManPi(p, Vec_IntEntry(vPiPermInv,i))->Value = Gia_ManAppendCi( pNew );
        Gia_ManPi(p, Vec_IntEntry(vPiPerm,i))->Value = Gia_ManAppendCi( pNew );
//    Vec_IntFree( vPiPermInv );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
        {
            if ( Gia_ObjIsRo(p, pObj) )
                pObj->Value = Gia_ManAppendCi( pNew );
        }
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupPermFlop()

Gia_Man_t * Gia_ManDupPermFlop	(	Gia_Man_t *	p,
		Vec_Int_t *	vFfPerm )

extern

Definition at line 962 of file giaDup.c.

{
    //Vec_Int_t * vPermInv;
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Vec_IntSize(vFfPerm) == Gia_ManRegNum(p) );
    //vPermInv = Vec_IntInvert( vFfPerm, -1 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachRo( p, pObj, i )
        //Gia_ManRo(p, Vec_IntEntry(vPermInv, i))->Value = Gia_ManAppendCi(pNew);
        Gia_ManRo(p, Vec_IntEntry(vFfPerm, i))->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachRi( p, pObj, i )
        //pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy( Gia_ManRi(p, Vec_IntEntry(vPermInv, i)) ) );
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy( Gia_ManRi(p, Vec_IntEntry(vFfPerm, i)) ) );
    //Vec_IntFree( vPermInv );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupPermFlopGap()

Gia_Man_t * Gia_ManDupPermFlopGap	(	Gia_Man_t *	p,
		Vec_Int_t *	vFfPerm )

extern

Definition at line 1026 of file giaDup.c.

{
    Vec_Int_t * vPerm = Vec_IntCondense( vFfMask, -1 );
    Gia_Man_t * pPerm = Gia_ManDupPermFlop( p, vPerm );
    Gia_Man_t * pSpread = Gia_ManDupSpreadFlop( pPerm, vFfMask );
    Vec_IntFree( vPerm );
    Gia_ManStop( pPerm );
    return pSpread;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupRemapEquiv()

void Gia_ManDupRemapEquiv	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p )

extern

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

Synopsis [Removes pointers to the unmarked nodes..]

Description []

SideEffects []

SeeAlso []

Definition at line 82 of file giaDup.c.

{
    Vec_Int_t * vClass;
    int i, k, iNode, iRepr, iPrev;
    if ( p->pReprs == NULL )
        return;
    assert( pNew->pReprs == NULL && pNew->pNexts == NULL );
    // start representatives
    pNew->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pNew) );
    for ( i = 0; i < Gia_ManObjNum(pNew); i++ )
        Gia_ObjSetRepr( pNew, i, GIA_VOID );
    // iterate over constant candidates
    Gia_ManForEachConst( p, i )
        Gia_ObjSetRepr( pNew, Abc_Lit2Var(Gia_ManObj(p, i)->Value), 0 );
    // iterate over class candidates
    vClass = Vec_IntAlloc( 100 );
    Gia_ManForEachClass( p, i )
    {
        Vec_IntClear( vClass );
        Gia_ClassForEachObj( p, i, k )
            Vec_IntPushUnique( vClass, Abc_Lit2Var(Gia_ManObj(p, k)->Value) );
        assert( Vec_IntSize( vClass ) > 1 );
        Vec_IntSort( vClass, 0 );
        iRepr = iPrev = Vec_IntEntry( vClass, 0 );
        Vec_IntForEachEntryStart( vClass, iNode, k, 1 )
        {
            Gia_ObjSetRepr( pNew, iNode, iRepr );
            assert( iPrev < iNode );
            iPrev = iNode;
        }
    }
    Vec_IntFree( vClass );
    pNew->pNexts = Gia_ManDeriveNexts( pNew );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupRemapLiterals()

void Gia_ManDupRemapLiterals	(	Vec_Int_t *	vLits,
		Gia_Man_t *	p )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Removes pointers to the unmarked nodes..]

Description [Array vLits contains literals of p. At the same time, each object pObj of p points to a literal of pNew. This procedure remaps literals in array vLits into literals of pNew.]

SideEffects []

SeeAlso []

Definition at line 54 of file giaDup.c.

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

Here is the caller graph for this function:

◆ Gia_ManDupRemovePis()

Gia_Man_t * Gia_ManDupRemovePis	(	Gia_Man_t *	p,
		int	nRemPis )

extern

Definition at line 802 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) && Gia_ObjCioId(pObj) < Gia_ManCiNum(p)-nRemPis )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupSelectedOutputs()

Gia_Man_t * Gia_ManDupSelectedOutputs	(	Gia_Man_t *	p,
		Vec_Int_t *	vOutsLeft )

extern

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

Synopsis [Duplicates AIG while putting objects in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 376 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i, iOut;
    assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManPoNum(p) >= Vec_IntSize(vOutsLeft) );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Vec_IntForEachEntry( vOutsLeft, iOut, i )
        Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(Gia_ManPo(p, iOut)) );
    Vec_IntForEachEntry( vOutsLeft, iOut, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, iOut)) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupSelf()

Gia_Man_t * Gia_ManDupSelf ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates while adding self-loops to the registers.]

Description []

SideEffects []

SeeAlso []

Definition at line 1359 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp; 
    Gia_Obj_t * pObj;
    int i, iCtrl;
    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;
    iCtrl = Gia_ManAppendCi( pNew );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ObjFanin0Copy(pObj);
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManHashMux( pNew, iCtrl, Gia_ObjFanin0Copy(pObj), Gia_ObjRiToRo(p, pObj)->Value );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManAppendCo( pNew, pObj->Value );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupSliced()

Gia_Man_t * Gia_ManDupSliced	(	Gia_Man_t *	p,
		int	nSuppMax )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 4211 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    // start the new manager
    pNew = Gia_ManStart( 5000 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    // create constant and PIs
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    // create internal nodes
    Gia_ManCleanMark01(p);
    Gia_ManForEachAnd( p, pObj, i )
        if ( Gia_ManSuppSize(p, &i, 1) <= nSuppMax )
        {
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
            pObj->fMark0 = 1;
        }
        else 
        {
            Gia_ObjFanin0(pObj)->fMark1 = 1;
            Gia_ObjFanin1(pObj)->fMark1 = 1;
        }
    Gia_ManForEachCo( p, pObj, i )
        Gia_ObjFanin0(pObj)->fMark1 = 1;
    // add POs for the nodes pointed to
    Gia_ManForEachAnd( p, pObj, i )
        if ( pObj->fMark0 && pObj->fMark1 )
            Gia_ManAppendCo( pNew, pObj->Value );
    // cleanup and leave
    Gia_ManCleanMark01(p);
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupTimes()

Gia_Man_t * Gia_ManDupTimes	(	Gia_Man_t *	p,
		int	nTimes )

extern

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

Synopsis [Duplicates AIG while creating "parallel" copies.]

Description []

SideEffects []

SeeAlso []

Definition at line 1547 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    Vec_Int_t * vPis, * vPos, * vRis, * vRos;
    int i, t, Entry;
    assert( nTimes > 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    vPis = Vec_IntAlloc( Gia_ManPiNum(p) * nTimes );
    vPos = Vec_IntAlloc( Gia_ManPoNum(p) * nTimes );
    vRis = Vec_IntAlloc( Gia_ManRegNum(p) * nTimes );
    vRos = Vec_IntAlloc( Gia_ManRegNum(p) * nTimes );
    for ( t = 0; t < nTimes; t++ )
    {
        Gia_ManForEachObj1( p, pObj, i )
        {
            if ( Gia_ObjIsAnd(pObj) )
                pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
            else if ( Gia_ObjIsCi(pObj) )
            {
                pObj->Value = Gia_ManAppendCi( pNew );
                if ( Gia_ObjIsPi(p, pObj) )
                    Vec_IntPush( vPis, Abc_Lit2Var(pObj->Value) );
                else
                    Vec_IntPush( vRos, Abc_Lit2Var(pObj->Value) );
            }
            else if ( Gia_ObjIsCo(pObj) )
            {
                pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
                if ( Gia_ObjIsPo(p, pObj) )
                    Vec_IntPush( vPos, Abc_Lit2Var(pObj->Value) );
                else
                    Vec_IntPush( vRis, Abc_Lit2Var(pObj->Value) );
            }
        }
    }
    Vec_IntClear( pNew->vCis );
    Vec_IntForEachEntry( vPis, Entry, i )
    {
        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCis) );
        Vec_IntPush( pNew->vCis, Entry );
    }
    Vec_IntForEachEntry( vRos, Entry, i )
    {
        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCis) );
        Vec_IntPush( pNew->vCis, Entry );
    }
    Vec_IntClear( pNew->vCos );
    Vec_IntForEachEntry( vPos, Entry, i )
    {
        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCos) );
        Vec_IntPush( pNew->vCos, Entry );
    }
    Vec_IntForEachEntry( vRis, Entry, i )
    {
        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCos) );
        Vec_IntPush( pNew->vCos, Entry );
    }
    Vec_IntFree( vPis );
    Vec_IntFree( vPos );
    Vec_IntFree( vRis );
    Vec_IntFree( vRos );
    Gia_ManSetRegNum( pNew, nTimes * Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupTopAnd()

Gia_Man_t * Gia_ManDupTopAnd	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis [Detect topmost gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 2930 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    int fContinue, iIter = 0;
    pNew = Gia_ManDupNormalize( p, 0 );
    for ( fContinue = 1; fContinue; )
    {
        pNew = Gia_ManDupTopAnd_iter( pTemp = pNew, fVerbose );
        if ( Gia_ManCoNum(pNew) == Gia_ManCoNum(pTemp) && Gia_ManAndNum(pNew) == Gia_ManAndNum(pTemp) )
            fContinue = 0;
        Gia_ManStop( pTemp );
        if ( fVerbose )
        {
            printf( "Iter %2d : ", ++iIter );
            Gia_ManPrintStatsShort( pNew );
        }
    }
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupTrimmed()

Gia_Man_t * Gia_ManDupTrimmed	(	Gia_Man_t *	p,
		int	fTrimCis,
		int	fTrimCos,
		int	fDualOut,
		int	OutValue )

extern

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

Synopsis [Duplicates AIG in the DFS order while putting CIs first.]

Description []

SideEffects []

SeeAlso []

Definition at line 2431 of file giaDup.c.

{
    Vec_Int_t * vNonZero = NULL;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, Entry;
    // collect non-zero
    if ( fDualOut && fTrimCos )
        vNonZero = Gia_ManDupTrimmedNonZero( p );
    // start new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    // check if there are PIs to be added
    Gia_ManCreateRefs( p );
    Gia_ManForEachPi( p, pObj, i )
        if ( !fTrimCis || Gia_ObjRefNum(p, pObj) )
            break;
    if ( i == Gia_ManPiNum(p) ) // there is no PIs - add dummy PI
        Gia_ManAppendCi(pNew);
    // add the ROs
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        if ( !fTrimCis || Gia_ObjRefNum(p, pObj) || Gia_ObjIsRo(p, pObj) )
            pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    if ( fDualOut && fTrimCos )
    {
        Vec_IntForEachEntry( vNonZero, Entry, i )
        {
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 2*Entry+0)) );
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 2*Entry+1)) );
        }
        if ( Gia_ManPoNum(pNew) == 0 ) // nothing - add dummy PO
        {
//            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 0)) );
//            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 1)) );
            Gia_ManAppendCo( pNew, 0 );
            Gia_ManAppendCo( pNew, 0 );
        }
        Gia_ManForEachRi( p, pObj, i )
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
        // cleanup
        pNew = Gia_ManSeqStructSweep( pTemp = pNew, 1, 1, 0 );
        Gia_ManStop( pTemp );
        // trim the PIs
//        pNew = Gia_ManDupTrimmed( pTemp = pNew, 1, 0, 0 );
//        Gia_ManStop( pTemp );
    }
    else
    {
        // check if there are POs to be added
        Gia_ManForEachPo( p, pObj, i )
            if ( !fTrimCos || !Gia_ManPoIsToRemove(p, pObj, OutValue) )
                break;
        if ( i == Gia_ManPoNum(p) ) // there is no POs - add dummy PO
            Gia_ManAppendCo( pNew, 0 );
        Gia_ManForEachCo( p, pObj, i )
            if ( !fTrimCos || !Gia_ManPoIsToRemove(p, pObj, OutValue) || Gia_ObjIsRi(p, pObj) )
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    }
    Vec_IntFreeP( &vNonZero );
    assert( !Gia_ManHasDangling( pNew ) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupUniv()

Gia_Man_t * Gia_ManDupUniv	(	Gia_Man_t *	p,
		int	iVar )

extern

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

Synopsis [Existentially quantified given variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 2059 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
    assert( Gia_ManRegNum(p) == 0 );
    Gia_ManFillValue( p );
    // find the cofactoring variable
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    // compute negative cofactor
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 0 );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ObjFanin0Copy(pObj);
    // compute the positive cofactor
    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 1 );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create OR gate
    Gia_ManForEachPo( p, pObj, i )
    {
        if ( i == 0 )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashAnd(pNew, Gia_ObjFanin0Copy(pObj), pObj->Value) );
        else 
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupUnnormalize()

Gia_Man_t * Gia_ManDupUnnormalize ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG according to the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 382 of file giaTim.c.

{
    Vec_Int_t * vNodes;
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( !Gia_ManBufNum(p) );
    vNodes = Gia_ManOrderWithBoxes( p );
    if ( vNodes == NULL )
        return NULL;
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    if ( Gia_ManHasChoices(p) )
        pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
    {
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
        {
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
            if ( Gia_ObjSibl(p, Gia_ObjId(p, pObj)) )
                pNew->pSibls[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var(Gia_ObjSiblObj(p, Gia_ObjId(p, pObj))->Value);        
        }
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsConst0(pObj) )
            pObj->Value = 0;
        else assert( 0 );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    Vec_IntFree( vNodes );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupUnshuffleInputs()

Gia_Man_t * Gia_ManDupUnshuffleInputs ( Gia_Man_t * p )

extern

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

Synopsis [Reorders flops for sequential AIGs with boxes.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file giaTim.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i, nCIs, nAll, nPis;
    // sanity checks
    assert( Gia_ManIsNormalized(p) );
    assert( Gia_ManIsSeqWithBoxes(p) );
    Gia_ManFillValue( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    // change input order
    // desired reorder:   PIs + NewCIs + FOs
    // current CI order:  PIs + FOs + NewCIs
    nCIs = Tim_ManPiNum( (Tim_Man_t *)p->pManTime );
    nAll = Tim_ManCiNum( (Tim_Man_t *)p->pManTime );
    nPis = nCIs - Gia_ManRegNum(p);
    assert( nAll == Gia_ManCiNum(p) );
    assert( nPis > 0 );
    // copy PIs first
    for ( i = 0; i < nPis; i++ )
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi(pNew);
    // copy flops second
    for ( i = nAll - Gia_ManRegNum(p); i < nAll; i++ )
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi(pNew);
    // copy new CIs last
    for ( i = nPis; i < nAll - Gia_ManRegNum(p); i++ )
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi(pNew);
    printf( "Warning: Unshuffled CI order to be correct AIG with boxes.\n" );
    // other things
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew->nConstrs = p->nConstrs;
    assert( Gia_ManIsNormalized(pNew) );
    Gia_ManDupRemapEquiv( pNew, p );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupWithAttributes()

Gia_Man_t * Gia_ManDupWithAttributes ( Gia_Man_t * p )

extern

Definition at line 776 of file giaDup.c.

{
    Gia_Man_t * pNew = Gia_ManDup(p);
    Gia_ManTransferMapping( pNew, p );
    Gia_ManTransferPacking( pNew, p );
    if ( p->pManTime )
        pNew->pManTime = Tim_ManDup( (Tim_Man_t *)p->pManTime, 0 );
    if ( p->pAigExtra )
        pNew->pAigExtra = Gia_ManDup( p->pAigExtra );
    if ( p->nAnd2Delay )
        pNew->nAnd2Delay = p->nAnd2Delay;
    if ( p->vRegClasses )
        pNew->vRegClasses = Vec_IntDup( p->vRegClasses );
    if ( p->vRegInits )
        pNew->vRegInits = Vec_IntDup( p->vRegInits );
    if ( p->vConfigs )
        pNew->vConfigs = Vec_IntDup( p->vConfigs );
    if ( p->pCellStr )
        pNew->pCellStr = Abc_UtilStrsav( p->pCellStr );
    // copy names if present
    if ( p->vNamesIn )
        pNew->vNamesIn = Vec_PtrDupStr( p->vNamesIn );
    if ( p->vNamesOut )
        pNew->vNamesOut = Vec_PtrDupStr( p->vNamesOut );        
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManDupWithConstraints()

Gia_Man_t * Gia_ManDupWithConstraints	(	Gia_Man_t *	p,
		Vec_Int_t *	vPoTypes )

extern

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

Synopsis [Duplicates AIG while putting first PIs, then nodes, then POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 3816 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i, nConstr = 0;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        if ( Vec_IntEntry(vPoTypes, i) == 0 ) // regular PO
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
        if ( Vec_IntEntry(vPoTypes, i) == 1 ) // constraint (should be complemented!)
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ^ 1 ), nConstr++;
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
//    Gia_ManDupRemapEquiv( pNew, p );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew->nConstrs = nConstr;
    assert( Gia_ManIsNormalized(pNew) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupWithNewPo()

Gia_Man_t * Gia_ManDupWithNewPo	(	Gia_Man_t *	p1,
		Gia_Man_t *	p2 )

extern

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

Synopsis [Duplicates transition relation from p1 and property from p2.]

Description []

SideEffects []

SeeAlso []

Definition at line 2634 of file giaDup.c.

{
    Gia_Man_t * pTemp, * pNew;
    Gia_Obj_t * pObj;
    int i;
    // there is no flops in p2
    assert( Gia_ManRegNum(p2) == 0 );
    // there is only one PO in p2
//    assert( Gia_ManPoNum(p2) == 1 );
    // input count of p2 is equal to flop count of p1 
    assert( Gia_ManPiNum(p2) == Gia_ManRegNum(p1) );
 
    // start new AIG
    pNew = Gia_ManStart( Gia_ManObjNum(p1)+Gia_ManObjNum(p2) );
    pNew->pName = Abc_UtilStrsav( p1->pName );
    pNew->pSpec = Abc_UtilStrsav( p1->pSpec );
    Gia_ManHashAlloc( pNew );
    // dup first AIG
    Gia_ManConst0(p1)->Value = 0;
    Gia_ManForEachCi( p1, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachAnd( p1, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // dup second AIG
    Gia_ManConst0(p2)->Value = 0;
    Gia_ManForEachPi( p2, pObj, i )
        pObj->Value = Gia_ManRo(p1, i)->Value;
    Gia_ManForEachAnd( p2, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // add property output
    Gia_ManForEachPo( p2, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    // add flop inputs
    Gia_ManForEachRi( p1, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p1) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupZero()

Gia_Man_t * Gia_ManDupZero ( Gia_Man_t * p )

extern

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 905 of file giaDup.c.

{
    Gia_Man_t * pNew; int i;
    pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Gia_ManCoNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    for ( i = 0; i < Gia_ManCiNum(p); i++ )
        Gia_ManAppendCi( pNew );
    for ( i = 0; i < Gia_ManCoNum(p); i++ )
        Gia_ManAppendCo( pNew, 0 );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManDupZeroUndc()

Gia_Man_t * Gia_ManDupZeroUndc	(	Gia_Man_t *	p,
		char *	pInit,
		int	nNewPis,
		int	fGiaSimple,
		int	fVerbose )

extern

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

Synopsis [Performs 'zero' and 'undc' operation.]

Description [The init string specifies 0/1/X for each flop.]

SideEffects []

SeeAlso []

Definition at line 3569 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int CountPis = Gia_ManPiNum(p), * pPiLits;
    int i, iResetFlop = -1, Count1 = 0;
    //printf( "Using %s\n", pInit );
    // map X-valued flops into new PIs
    assert( (int)strlen(pInit) == Gia_ManRegNum(p) );
    pPiLits = ABC_FALLOC( int, Gia_ManRegNum(p) );
    for ( i = 0; i < Gia_ManRegNum(p); i++ )
        if ( pInit[i] == 'x' || pInit[i] == 'X' )
            pPiLits[i] = CountPis++;
    // create new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->fGiaSimple = fGiaSimple;
    Gia_ManConst0(p)->Value = 0;
    // create primary inputs
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    // create additional primary inputs
    for ( i = Gia_ManPiNum(p); i < CountPis; i++ )
        Gia_ManAppendCi( pNew );
    // create additional primary inputs
    for ( i = 0; i < nNewPis; i++ )
        Gia_ManAppendCi( pNew );
    // create flop outputs
    Gia_ManForEachRo( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    // create reset flop output
    if ( CountPis > Gia_ManPiNum(p) )
        iResetFlop = Gia_ManAppendCi( pNew );
    // update flop outputs
    Gia_ManMarkFanoutDrivers( p );
    Gia_ManForEachRo( p, pObj, i )
    {
        if ( pInit[i] == '1' )
            pObj->Value = Abc_LitNot(pObj->Value), Count1++;
        else if ( pInit[i] == 'x' || pInit[i] == 'X' )
        {
            if ( pObj->fMark0 ) // only add MUX if the flop has fanout
                pObj->Value = Gia_ManAppendMux( pNew, iResetFlop, pObj->Value, Gia_Obj2Lit(pNew, Gia_ManPi(pNew, pPiLits[i])) );
        }
        else if ( pInit[i] != '0' )
            assert( 0 );
    }
    Gia_ManCleanMark0( p );
    ABC_FREE( pPiLits );
    // build internal nodes
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // create POs
    Gia_ManForEachPo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    // create flop inputs
    Gia_ManForEachRi( p, pObj, i )
        if ( pInit[i] == '1' )
            pObj->Value = Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ObjFanin0Copy(pObj)) );
        else
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    // create reset flop input
    if ( CountPis > Gia_ManPiNum(p) )
        Gia_ManAppendCo( pNew, 1 );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) + (int)(CountPis > Gia_ManPiNum(p)) );
    if ( fVerbose )
        printf( "Converted %d 1-valued FFs and %d DC-valued FFs.\n", Count1, CountPis-Gia_ManPiNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEdgeFromArray()

void Gia_ManEdgeFromArray	(	Gia_Man_t *	p,
		Vec_Int_t *	vArray )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Transforms edge assignment.]

Description []

SideEffects []

SeeAlso []

Definition at line 72 of file giaEdge.c.

{
    int i, iObj1, iObj2, Count = 0;
    Vec_IntFreeP( &p->vEdge1 );
    Vec_IntFreeP( &p->vEdge2 );
    p->vEdge1 = Vec_IntStart( Gia_ManObjNum(p) );
    p->vEdge2 = Vec_IntStart( Gia_ManObjNum(p) );
    Vec_IntForEachEntryDouble( vArray, iObj1, iObj2, i )
    {
        assert( iObj1 < iObj2 );
        Count += Gia_ObjEdgeAdd( iObj1, iObj2, p->vEdge1, p->vEdge2 );
        Count += Gia_ObjEdgeAdd( iObj2, iObj1, p->vEdge1, p->vEdge2 );
    }
    if ( Count ) 
        printf( "Found %d violations during edge conversion.\n", Count );
}

Here is the caller graph for this function:

◆ Gia_ManEdgeToArray()

Vec_Int_t * Gia_ManEdgeToArray ( Gia_Man_t * p )

extern

Definition at line 88 of file giaEdge.c.

{
    int iObj, iFanin;
    Vec_Int_t * vArray = Vec_IntAlloc( 1000 );
    assert( p->vEdge1 && p->vEdge2 );
    assert( Vec_IntSize(p->vEdge1) == Gia_ManObjNum(p) );
    assert( Vec_IntSize(p->vEdge2) == Gia_ManObjNum(p) );
    for ( iObj = 0; iObj < Gia_ManObjNum(p); iObj++ )
    {
        iFanin = Vec_IntEntry( p->vEdge1, iObj );
        if ( iFanin && iFanin < iObj )
            Vec_IntPushTwo( vArray, iFanin, iObj );
        iFanin = Vec_IntEntry( p->vEdge2, iObj );
        if ( iFanin && iFanin < iObj )
            Vec_IntPushTwo( vArray, iFanin, iObj );
    }
    return vArray;
}

Here is the caller graph for this function:

◆ Gia_ManEquivCountClasses()

int Gia_ManEquivCountClasses ( Gia_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 376 of file giaEquiv.c.

{
    int i, Counter = 0;
    if ( p->pReprs == NULL )
        return 0;
    for ( i = 1; i < Gia_ManObjNum(p); i++ )
        Counter += Gia_ObjIsHead(p, i);
    return Counter;
}

◆ Gia_ManEquivCountLits()

int Gia_ManEquivCountLits ( Gia_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 450 of file giaEquiv.c.

{
    int i, Counter = 0, Counter0 = 0, CounterX = 0;
    if ( p->pReprs == NULL || p->pNexts == NULL )
        return 0;
    for ( i = 1; i < Gia_ManObjNum(p); i++ )
    {
        if ( Gia_ObjIsHead(p, i) )
            Counter++;
        else if ( Gia_ObjIsConst(p, i) )
            Counter0++;
        else if ( Gia_ObjIsNone(p, i) )
            CounterX++;
    }
    CounterX -= Gia_ManCoNum(p);
    return Gia_ManCiNum(p) + Gia_ManAndNum(p) - Counter - CounterX;
}

Here is the caller graph for this function:

◆ Gia_ManEquivCountLitsAll()

int Gia_ManEquivCountLitsAll ( Gia_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 357 of file giaEquiv.c.

{
    int i, nLits = 0;
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
        nLits += (Gia_ObjRepr(p, i) != GIA_VOID);
    return nLits;
}

Here is the caller graph for this function:

◆ Gia_ManEquivFixOutputPairs()

void Gia_ManEquivFixOutputPairs ( Gia_Man_t * p )

extern

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 882 of file giaEquiv.c.

{
    Gia_Obj_t * pObj0, * pObj1;
    int i;
    assert( (Gia_ManPoNum(p) & 1) == 0 );
    Gia_ManForEachPo( p, pObj0, i )
    {
        pObj1 = Gia_ManPo( p, ++i );
        if ( Gia_ObjChild0(pObj0) != Gia_ObjChild0(pObj1) )
            continue;
        pObj0->iDiff0  = Gia_ObjId(p, pObj0);
        pObj0->fCompl0 = 0;
        pObj1->iDiff0  = Gia_ObjId(p, pObj1);
        pObj1->fCompl0 = 0;
    }
}

Here is the caller graph for this function:

◆ Gia_ManEquivImprove()

void Gia_ManEquivImprove ( Gia_Man_t * p )

extern

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

Synopsis [Transforms equiv classes by setting a good representative.]

Description []

SideEffects []

SeeAlso []

Definition at line 1780 of file giaEquiv.c.

{
    Vec_Int_t * vClass;
    int i, k, iNode, iRepr;
    int iReprBest, iLevelBest, iLevelCur, iMffcBest, iMffcCur;
    assert( p->pReprs != NULL && p->pNexts != NULL );
    Gia_ManLevelNum( p );
    Gia_ManCreateRefs( p );
    // iterate over class candidates
    vClass = Vec_IntAlloc( 100 );
    Gia_ManForEachClass( p, i )
    {
        Vec_IntClear( vClass );
        iReprBest = -1;
        iLevelBest = iMffcBest = ABC_INFINITY;
        Gia_ClassForEachObj( p, i, k )
        {
            iLevelCur = Gia_ObjLevel( p,Gia_ManObj(p, k) );
            iMffcCur  = Gia_NodeMffcSize( p, Gia_ManObj(p, k) );
            if ( iLevelBest > iLevelCur || (iLevelBest == iLevelCur && iMffcBest > iMffcCur) )
            {
                iReprBest  = k;
                iLevelBest = iLevelCur;
                iMffcBest  = iMffcCur;
            }
            Vec_IntPush( vClass, k );
        }
        assert( Vec_IntSize( vClass ) > 1 );
        assert( iReprBest > 0 );
        if ( i == iReprBest )
            continue;
/*
        Abc_Print( 1, "Repr/Best = %6d/%6d. Lev = %3d/%3d. Mffc = %3d/%3d.\n", 
            i, iReprBest, Gia_ObjLevel( p,Gia_ManObj(p, i) ), Gia_ObjLevel( p,Gia_ManObj(p, iReprBest) ),
            Gia_NodeMffcSize( p, Gia_ManObj(p, i) ), Gia_NodeMffcSize( p, Gia_ManObj(p, iReprBest) ) );
*/
        iRepr = iReprBest;
        Gia_ObjSetRepr( p, iRepr, GIA_VOID );
        Gia_ObjSetProved( p, i );
        Gia_ObjUnsetProved( p, iRepr );
        Vec_IntForEachEntry( vClass, iNode, k )
            if ( iNode != iRepr )
                Gia_ObjSetRepr( p, iNode, iRepr );
    }
    Vec_IntFree( vClass );
    ABC_FREE( p->pNexts );
//    p->pNexts = Gia_ManDeriveNexts( p );
}

Here is the call graph for this function:

◆ Gia_ManEquivPrintClasses()

void Gia_ManEquivPrintClasses	(	Gia_Man_t *	p,
		int	fVerbose,
		float	Mem )

extern

Definition at line 501 of file giaEquiv.c.

{
    int i, Counter = 0, Counter0 = 0, CounterX = 0, Proved = 0, nLits;
    for ( i = 1; i < Gia_ManObjNum(p); i++ )
    {
        if ( Gia_ObjIsHead(p, i) )
            Counter++;
        else if ( Gia_ObjIsConst(p, i) )
            Counter0++;
        else if ( Gia_ObjIsNone(p, i) )
            CounterX++;
        if ( Gia_ObjProved(p, i) )
            Proved++;
    }
    CounterX -= Gia_ManCoNum(p);
    nLits = Gia_ManCiNum(p) + Gia_ManAndNum(p) - Counter - CounterX;
//    Abc_Print( 1, "cst =%8d  cls =%7d  lit =%8d  unused =%8d  proof =%6d  mem =%5.2f MB\n",
//        Counter0, Counter, nLits, CounterX, Proved, (Mem == 0.0) ? 8.0*Gia_ManObjNum(p)/(1<<20) : Mem );
    Abc_Print( 1, "cst =%8d  cls =%7d  lit =%8d  unused =%8d  proof =%6d\n",
        Counter0, Counter, nLits, CounterX, Proved );
    assert( Gia_ManEquivCheckLits( p, nLits ) );
    if ( fVerbose )
    {
//        int Ent;
        Abc_Print( 1, "Const0 (%d) = ", Counter0 );
        Gia_ManForEachConst( p, i )
            Abc_Print( 1, "%d ", i );
        Abc_Print( 1, "\n" );
        Counter = 0;
        Gia_ManForEachClass( p, i )
            Gia_ManEquivPrintOne( p, i, ++Counter );
/*
        Gia_ManLevelNum( p );
        Gia_ManForEachClass( p, i )
            if ( i % 100 == 0 )
            {
//                Abc_Print( 1, "%d ", Gia_ManEquivCountOne(p, i) );
                Gia_ClassForEachObj( p, i, Ent )
                {
                    Abc_Print( 1, "%d ", Gia_ObjLevel( p, Gia_ManObj(p, Ent) ) );
                }
                Abc_Print( 1, "\n" );
            }
*/
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEquivPrintOne()

void Gia_ManEquivPrintOne	(	Gia_Man_t *	p,
		int	i,
		int	Counter )

extern

Definition at line 489 of file giaEquiv.c.

{
    int Ent;
    Abc_Print( 1, "Class %4d :  Num = %2d  {", Counter, Gia_ManEquivCountOne(p, i) );
    Gia_ClassForEachObj( p, i, Ent )
    {
        Abc_Print( 1," %d", Ent );
        if ( p->pReprs[Ent].fColorA || p->pReprs[Ent].fColorB )
            Abc_Print( 1," <%d%d>", p->pReprs[Ent].fColorA, p->pReprs[Ent].fColorB );
    }
    Abc_Print( 1, " }\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEquivReduce()

Gia_Man_t * Gia_ManEquivReduce	(	Gia_Man_t *	p,
		int	fUseAll,
		int	fDualOut,
		int	fSkipPhase,
		int	fVerbose )

extern

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 677 of file giaEquiv.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    if ( !p->pReprs && p->pSibls )
    {
        int * pMap = ABC_FALLOC( int, Gia_ManObjNum(p) );
        p->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p) );
        for ( i = 0; i < Gia_ManObjNum(p); i++ )
            Gia_ObjSetRepr( p, i, GIA_VOID );
        for ( i = 0; i < Gia_ManObjNum(p); i++ )
            if ( p->pSibls[i] > 0 )
            {
                if ( pMap[p->pSibls[i]] == -1 )
                    pMap[p->pSibls[i]] = p->pSibls[i];
                pMap[i] = pMap[p->pSibls[i]];
            }
        for ( i = 0; i < Gia_ManObjNum(p); i++ )
            if ( p->pSibls[i] > 0 )
                Gia_ObjSetRepr( p, i, pMap[i] );
        //printf( "Created equivalence classes.\n" );
        ABC_FREE( p->pNexts );
        p->pNexts = Gia_ManDeriveNexts( p );
        ABC_FREE( pMap );
    }
    if ( !p->pReprs )
    {
        Abc_Print( 1, "Gia_ManEquivReduce(): Equivalence classes are not available.\n" );
        return NULL;
    }
    if ( fDualOut && (Gia_ManPoNum(p) & 1) )
    {
        Abc_Print( 1, "Gia_ManEquivReduce(): Dual-output miter should have even number of POs.\n" );
        return NULL;
    }
    // check if there are any equivalences defined
    Gia_ManForEachObj( p, pObj, i )
        if ( Gia_ObjReprObj(p, i) != NULL )
            break;
    if ( i == Gia_ManObjNum(p) )
    {
//        Abc_Print( 1, "Gia_ManEquivReduce(): There are no equivalences to reduce.\n" );
//        return NULL;
        return Gia_ManDup( p );
    }
/*
    if ( !Gia_ManCheckTopoOrder( p ) )
    {
        Abc_Print( 1, "Gia_ManEquivReduce(): AIG is not in a correct topological order.\n" );
        return NULL;
    }
*/
    if ( !fSkipPhase )
        Gia_ManSetPhase( p );
    if ( fDualOut )
        Gia_ManEquivSetColors( p, fVerbose );
    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, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManEquivReduce_rec( pNew, p, Gia_ObjFanin0(pObj), fUseAll, fDualOut );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEquivReduceAndRemap()

Gia_Man_t * Gia_ManEquivReduceAndRemap	(	Gia_Man_t *	p,
		int	fSeq,
		int	fMiterPairs )

extern

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

Synopsis [Reduces AIG while remapping equivalence classes.]

Description [Drops the pairs of outputs if they are proved equivalent.]

SideEffects []

SeeAlso []

Definition at line 1040 of file giaEquiv.c.

{
    Gia_Man_t * pNew, * pFinal;
    pNew = Gia_ManEquivReduce( p, 0, 0, 0, 0 );
    if ( pNew == NULL )
        return NULL;
    Gia_ManOrigIdsRemap( p, pNew );
    if ( fMiterPairs )
        Gia_ManEquivFixOutputPairs( pNew );
    if ( fSeq )
        Gia_ManSeqMarkUsed( pNew );
    else
        Gia_ManCombMarkUsed( pNew );
    Gia_ManEquivUpdatePointers( p, pNew );
    pFinal = Gia_ManDupMarked( pNew );
    Gia_ManOrigIdsRemap( pNew, pFinal );
    Gia_ManEquivDeriveReprs( p, pNew, pFinal );
    Gia_ManStop( pNew );
    pFinal = Gia_ManEquivRemapDfs( pNew = pFinal );
    Gia_ManOrigIdsRemap( pNew, pFinal );
    Gia_ManStop( pNew );
    return pFinal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEquivSetColors()

int Gia_ManEquivSetColors	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis [Marks CIs/COs/ANDs unreachable from POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1097 of file giaEquiv.c.

{
    Gia_Obj_t * pObj;
    int i, nNodes[2], nDiffs[2];
    assert( (Gia_ManPoNum(p) & 1) == 0 );
    Gia_ObjSetColors( p, 0 );
    Gia_ManForEachPi( p, pObj, i )
        Gia_ObjSetColors( p, Gia_ObjId(p,pObj) );
    nNodes[0] = nNodes[1] = Gia_ManPiNum(p);
    Gia_ManForEachPo( p, pObj, i )
        nNodes[i&1] += Gia_ManEquivSetColor_rec( p, Gia_ObjFanin0(pObj), i&1 );
//    Gia_ManForEachObj( p, pObj, i )
//        if ( Gia_ObjIsCi(pObj) || Gia_ObjIsAnd(pObj) )
//            assert( Gia_ObjColors(p, i) );
    nDiffs[0] = Gia_ManCandNum(p) - nNodes[0];
    nDiffs[1] = Gia_ManCandNum(p) - nNodes[1];
    if ( fVerbose )
    {
        Abc_Print( 1, "CI+AND = %7d  A = %7d  B = %7d  Ad = %7d  Bd = %7d  AB = %7d.\n",
            Gia_ManCandNum(p), nNodes[0], nNodes[1], nDiffs[0], nDiffs[1],
            Gia_ManCandNum(p) - nDiffs[0] - nDiffs[1] );
    }
    return (nDiffs[0] + nDiffs[1]) / 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEquivToChoices()

Gia_Man_t * Gia_ManEquivToChoices	(	Gia_Man_t *	p,
		int	nSnapshots )

extern

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 2034 of file giaEquiv.c.

{
    Vec_Int_t * vNodes;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pRepr;
    int i;
//Gia_ManEquivPrintClasses( p, 0, 0 );
    assert( (Gia_ManCoNum(p) % nSnapshots) == 0 );
    Gia_ManSetPhase( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p) );
    pNew->pNexts = ABC_CALLOC( int, Gia_ManObjNum(p) );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
        pNew->pReprs[i].iRepr = GIA_VOID;
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachRo( p, pObj, i )
        if ( (pRepr = Gia_ObjReprObj(p, Gia_ObjId(p, pObj))) )
        {
            assert( Gia_ObjIsConst0(pRepr) || Gia_ObjIsRo(p, pRepr) );
            pObj->Value = pRepr->Value;
        }
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManEquivToChoices_rec( pNew, p, Gia_ObjFanin0(pObj) );
    vNodes = Gia_ManGetDangling( p );
    Gia_ManForEachObjVec( vNodes, p, pObj, i )
        Gia_ManEquivToChoices_rec( pNew, p, pObj );
    Vec_IntFree( vNodes );
    Gia_ManForEachCo( p, pObj, i )
        if ( i % nSnapshots == 0 )
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    Gia_ManRemoveBadChoices( pNew );
//Gia_ManEquivPrintClasses( pNew, 0, 0 );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
//Gia_ManEquivPrintClasses( pNew, 0, 0 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEquivTransform()

void Gia_ManEquivTransform	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis [Transforms equiv classes by removing the AB nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1519 of file giaEquiv.c.

{
    extern void Cec_ManSimClassCreate( Gia_Man_t * p, Vec_Int_t * vClass );
    Vec_Int_t * vClass, * vClassNew;
    int iRepr, iNode, Ent, k;
    int nRemovedLits = 0, nRemovedClas = 0;
    int nTotalLits = 0, nTotalClas = 0;
    Gia_Obj_t * pObj;
    int i;
    assert( p->pReprs && p->pNexts );
    vClass = Vec_IntAlloc( 100 );
    vClassNew = Vec_IntAlloc( 100 );
    Gia_ManForEachObj( p, pObj, i )
        if ( Gia_ObjIsCi(pObj) || Gia_ObjIsAnd(pObj) )
            assert( Gia_ObjColors(p, i) );
    Gia_ManForEachClassReverse( p, iRepr )
    {
        nTotalClas++;
        Vec_IntClear( vClass );
        Vec_IntClear( vClassNew );
        Gia_ClassForEachObj( p, iRepr, iNode )
        {
            nTotalLits++;
            Vec_IntPush( vClass, iNode );
            assert( Gia_ObjColors(p, iNode) );
            if ( Gia_ObjColors(p, iNode) != 3 )
                Vec_IntPush( vClassNew, iNode );
            else
                nRemovedLits++;
        }
        Vec_IntForEachEntry( vClass, Ent, k )
        {
            p->pReprs[Ent].fFailed = p->pReprs[Ent].fProved = 0;
            p->pReprs[Ent].iRepr = GIA_VOID;
            p->pNexts[Ent] = 0;
        }
        if ( Vec_IntSize(vClassNew) < 2 )
        {
            nRemovedClas++;
            continue;
        }
        Cec_ManSimClassCreate( p, vClassNew );
    }
    Vec_IntFree( vClass );
    Vec_IntFree( vClassNew );
    if ( fVerbose )
    Abc_Print( 1, "Removed classes = %6d (out of %6d). Removed literals = %6d (out of %6d).\n",
        nRemovedClas, nTotalClas, nRemovedLits, nTotalLits );
}

Here is the call graph for this function:

◆ Gia_ManEvalEdgeCount()

int Gia_ManEvalEdgeCount ( Gia_Man_t * p )

extern

Definition at line 284 of file giaEdge.c.

{
    return (Vec_IntCountPositive(p->vEdge1) + Vec_IntCountPositive(p->vEdge2))/2;
}

Here is the caller graph for this function:

◆ Gia_ManEvalEdgeDelay()

int Gia_ManEvalEdgeDelay ( Gia_Man_t * p )

extern

Definition at line 201 of file giaEdge.c.

{
    int k, iLut, DelayMax = 0;
    assert( p->vEdge1 && p->vEdge2 );
    Vec_IntFreeP( &p->vEdgeDelay );
    p->vEdgeDelay = Vec_IntStart( Gia_ManObjNum(p) );
    if ( Gia_ManHasMapping(p) )
    {
        if ( p->pManTime != NULL && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) )
        {
            Gia_Obj_t * pObj; 
            Vec_Int_t * vNodes = Gia_ManOrderWithBoxes( p );
            Tim_ManIncrementTravId( (Tim_Man_t*)p->pManTime );
            Gia_ManForEachObjVec( vNodes, p, pObj, k )
            {
                iLut = Gia_ObjId( p, pObj );
                if ( Gia_ObjIsAnd(pObj) )
                {
                    if ( Gia_ObjIsLut(p, iLut) )
                        Vec_IntWriteEntry( p->vEdgeDelay, iLut, Gia_ObjEvalEdgeDelay(p, iLut, p->vEdgeDelay) );
                }
                else if ( Gia_ObjIsCi(pObj) )
                {
                    int arrTime = Tim_ManGetCiArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj) );
                    Vec_IntWriteEntry( p->vEdgeDelay,  iLut, arrTime );
                }
                else if ( Gia_ObjIsCo(pObj) )
                {
                    int arrTime = Vec_IntEntry( p->vEdgeDelay, Gia_ObjFaninId0(pObj, iLut) );
                    Tim_ManSetCoArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj), arrTime );
                }
                else if ( !Gia_ObjIsConst0(pObj) ) 
                    assert( 0 );
            }
            Vec_IntFree( vNodes );
        }
        else
        {
            Gia_ManForEachLut( p, iLut )
                Vec_IntWriteEntry( p->vEdgeDelay, iLut, Gia_ObjEvalEdgeDelay(p, iLut, p->vEdgeDelay) );
        }
    }
    else if ( Gia_ManHasMapping2(p) )
    {
        if ( p->pManTime != NULL && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) )
        {
            Gia_Obj_t * pObj; 
            Vec_Int_t * vNodes = Gia_ManOrderWithBoxes( p );
            Tim_ManIncrementTravId( (Tim_Man_t*)p->pManTime );
            Gia_ManForEachObjVec( vNodes, p, pObj, k )
            {
                iLut = Gia_ObjId( p, pObj );
                if ( Gia_ObjIsAnd(pObj) )
                {
                    if ( Gia_ObjIsLut2(p, iLut) )
                        Vec_IntWriteEntry( p->vEdgeDelay, iLut, Gia_ObjEvalEdgeDelay(p, iLut, p->vEdgeDelay) );
                }
                else if ( Gia_ObjIsCi(pObj) )
                {
                    int arrTime = Tim_ManGetCiArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj) );
                    Vec_IntWriteEntry( p->vEdgeDelay,  iLut, arrTime );
                }
                else if ( Gia_ObjIsCo(pObj) )
                {
                    int arrTime = Vec_IntEntry( p->vEdgeDelay, Gia_ObjFaninId0(pObj, iLut) );
                    Tim_ManSetCoArrival( (Tim_Man_t*)p->pManTime, Gia_ObjCioId(pObj), arrTime );
                }
                else if ( !Gia_ObjIsConst0(pObj) ) 
                    assert( 0 );
            }
            Vec_IntFree( vNodes );
        }
        else
        {
            Gia_ManForEachLut2( p, iLut )
                Vec_IntWriteEntry( p->vEdgeDelay, iLut, Gia_ObjEvalEdgeDelay(p, iLut, p->vEdgeDelay) );
        }
    }
    else assert( 0 );
    Gia_ManForEachCoDriverId( p, iLut, k )
        DelayMax = Abc_MaxInt( DelayMax, Vec_IntEntry(p->vEdgeDelay, iLut) );
    return DelayMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEvalSolutionOne()

int Gia_ManEvalSolutionOne	(	Gia_Man_t *	p,
		Vec_Wrd_t *	vSims,
		Vec_Wrd_t *	vIsfs,
		Vec_Int_t *	vCands,
		Vec_Int_t *	vSet,
		int	nWords,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 277 of file giaDecs.c.

{
    Vec_Wrd_t * vTruths = Gia_ManDeriveTruths( p, vSims, vIsfs, vCands, vSet, nWords );
    int nTtWords = Vec_WrdSize(vTruths)/2, nVars = Vec_IntSize(vSet);
    word * pTruth[2] = { Vec_WrdEntryP(vTruths, 0*nTtWords), 
                         Vec_WrdEntryP(vTruths, 1*nTtWords) };
    int nNodesResub = Gia_ManCountResub( vTruths, nVars, 0 );
    int nNodesBidec = nVars > 2 ? Gia_ManCountBidec( vTruths, nVars, 0 ) : 999;
    int nNodesIsop  = nVars > 2 ? Gia_ManCountIsop( vTruths, nVars, 0 ) : 999;
    int nNodesBdd   = nVars > 2 ? Gia_ManCountBdd( vTruths, nVars, 0 ) : 999;
    int nNodesMin   = Abc_MinInt( Abc_MinInt(nNodesResub, nNodesBidec), Abc_MinInt(nNodesIsop, nNodesBdd) );
    if ( fVerbose )
    {
        printf( "Size = %2d  ", nVars );
        printf( "Resub =%3d  ", nNodesResub );
        printf( "Bidec =%3d  ", nNodesBidec );
        printf( "Isop =%3d  ",  nNodesIsop );
        printf( "Bdd =%3d  ",   nNodesBdd );
        Abc_TtIsfPrint( pTruth[0], pTruth[1], nTtWords ); 
        if ( nVars <= 6 )
        {
            printf( "  " );
            Extra_PrintHex( stdout, (unsigned*)pTruth[0], nVars );
            printf( "  " );
            Extra_PrintHex( stdout, (unsigned*)pTruth[1], nVars );
        }
        printf( "\n" );
    }
    Vec_WrdFree( vTruths );
    if ( nNodesMin > 500 )
        return -1;
    if ( nNodesMin == nNodesResub )
        return (nNodesMin << 2) | 0;
    if ( nNodesMin == nNodesBidec )
        return (nNodesMin << 2) | 1;
    if ( nNodesMin == nNodesIsop )
        return (nNodesMin << 2) | 2;
    if ( nNodesMin == nNodesBdd )
        return (nNodesMin << 2) | 3;
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManEvaluateSwitching()

float Gia_ManEvaluateSwitching ( Gia_Man_t * p )

extern

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

Synopsis [Computes probability of switching (or of being 1).]

Description []

SideEffects []

SeeAlso []

Definition at line 746 of file giaSwitch.c.

{
    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;
}

Here is the call graph for this function:

◆ Gia_ManEvalWindow()

int Gia_ManEvalWindow	(	Gia_Man_t *	p,
		Vec_Int_t *	vLeaves,
		Vec_Int_t *	vNodes,
		Vec_Wec_t *	vWin,
		Vec_Int_t *	vTemp,
		int	fUseTwo )

extern

Definition at line 633 of file giaEdge.c.

{
    int DelayMax;
    assert( Vec_IntSize(vNodes) == Vec_WecSize(vWin) );
    Gia_ManUpdateMapping( p, vNodes, vWin );
    DelayMax = Gia_ManComputeEdgeDelay( p, fUseTwo );
    Gia_ManUpdateMapping( p, vNodes, vWin );
    return DelayMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManExtractWindow()

Gia_Man_t * Gia_ManExtractWindow	(	Gia_Man_t *	p,
		int	LevelMax,
		int	nTimeWindow,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 236 of file giaBalMap.c.

{
    Vec_Int_t * vOuts;
    Gia_Man_t * pWin;
    assert( !LevelMax != !nTimeWindow );
    vOuts = Gia_ManFindLatest( p, LevelMax, nTimeWindow );
    if ( fVerbose )
        printf( "Collected %d outputs to extract.\n", Vec_IntSize(vOuts) );
    if ( Vec_IntSize(vOuts) == 0 )
    {
        Vec_IntFree( vOuts );
        return Gia_ManDup( p );
    }
    pWin = Gia_ManExtractWin( p, vOuts, 1 );
    Vec_IntFree( vOuts );
    return pWin;
}

Here is the call graph for this function:

◆ Gia_ManFanoutStart()

void Gia_ManFanoutStart ( Gia_Man_t * p )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Create fanout for all objects in the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 66 of file giaFanout.c.

{
    Gia_Obj_t * pObj;
    int i;
    // allocate fanout datastructure
    assert( p->pFanData == NULL );
    p->nFansAlloc = 2 * Gia_ManObjNum(p);
    if ( p->nFansAlloc < (1<<12) )
        p->nFansAlloc = (1<<12);
    p->pFanData = ABC_ALLOC( int, 5 * p->nFansAlloc );
    memset( p->pFanData, 0, sizeof(int) * 5 * p->nFansAlloc );
    // add fanouts for all objects
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjChild0(pObj) )
            Gia_ObjAddFanout( p, Gia_ObjFanin0(pObj), pObj );
        if ( Gia_ObjChild1(pObj) )
            Gia_ObjAddFanout( p, Gia_ObjFanin1(pObj), pObj );
    }
}

Here is the call graph for this function:

◆ Gia_ManFanoutStop()

void Gia_ManFanoutStop ( Gia_Man_t * p )

extern

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

Synopsis [Deletes fanout for all objects in the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 98 of file giaFanout.c.

{
    assert( p->pFanData != NULL );
    ABC_FREE( p->pFanData );
    p->nFansAlloc = 0;
}

◆ Gia_ManFillValue()

void Gia_ManFillValue ( Gia_Man_t * p )

extern

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_ManFilterEquivsForSpeculation()

int Gia_ManFilterEquivsForSpeculation	(	Gia_Man_t *	pGia,
		char *	pName1,
		char *	pName2,
		int	fLatchA,
		int	fLatchB )

extern

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 2267 of file giaEquiv.c.

{
    Gia_Man_t * pGia1, * pGia2, * pMiter;
    Gia_Obj_t * pObj1, * pObj2, * pObjM, * pObj;
    int i, iObj, iNext, Counter = 0;
    if ( pGia->pReprs == NULL || pGia->pNexts == NULL )
    {
        Abc_Print( 1, "Equivalences are not defined.\n" );
        return 0;
    }
    pGia1 = Gia_AigerRead( pName1, 0, 0, 0 );
    if ( pGia1 == NULL )
    {
        Abc_Print( 1, "Cannot read first file %s.\n", pName1 );
        return 0;
    }
    pGia2 = Gia_AigerRead( pName2, 0, 0, 0 );
    if ( pGia2 == NULL )
    {
        Gia_ManStop( pGia2 );
        Abc_Print( 1, "Cannot read second file %s.\n", pName2 );
        return 0;
    }
    pMiter = Gia_ManMiter( pGia1, pGia2, 0, 0, 1, 0, 0 );
    if ( pMiter == NULL )
    {
        Gia_ManStop( pGia1 );
        Gia_ManStop( pGia2 );
        Abc_Print( 1, "Cannot create sequential miter.\n" );
        return 0;
    }
    // make sure the miter is isomorphic
    if ( Gia_ManObjNum(pGia) != Gia_ManObjNum(pMiter) )
    {
        Gia_ManStop( pGia1 );
        Gia_ManStop( pGia2 );
        Gia_ManStop( pMiter );
        Abc_Print( 1, "The number of objects in different.\n" );
        return 0;
    }
    if ( memcmp( pGia->pObjs, pMiter->pObjs, sizeof(Gia_Obj_t) *  Gia_ManObjNum(pGia) ) )
    {
        Gia_ManStop( pGia1 );
        Gia_ManStop( pGia2 );
        Gia_ManStop( pMiter );
        Abc_Print( 1, "The AIG structure of the miter does not match.\n" );
        return 0;
    }
    // transfer copies
    Gia_ManCleanMark0( pGia );
    Gia_ManForEachObj( pGia1, pObj1, i )
    {
        if ( pObj1->Value == ~0 )
            continue;
        pObjM = Gia_ManObj( pMiter, Abc_Lit2Var(pObj1->Value) );
        pObj = Gia_ManObj( pGia, Gia_ObjId(pMiter, pObjM) );
        pObj->fMark0 = 1;
    }
    Gia_ManCleanMark1( pGia );
    Gia_ManForEachObj( pGia2, pObj2, i )
    {
        if ( pObj2->Value == ~0 )
            continue;
        pObjM = Gia_ManObj( pMiter, Abc_Lit2Var(pObj2->Value) );
        pObj = Gia_ManObj( pGia, Gia_ObjId(pMiter, pObjM) );
        pObj->fMark1 = 1;
    }
 
    // filter equivalences
    Gia_ManForEachConst( pGia, i )
    {
        Gia_ObjUnsetRepr( pGia, i );
        assert( pGia->pNexts[i] == 0 );
    }
    Gia_ManForEachClass( pGia, i )
    {
        // find the first colorA and colorB
        int ClassA = -1, ClassB = -1;
        Gia_ClassForEachObj( pGia, i, iObj )
        {
            pObj = Gia_ManObj( pGia, iObj );
            if ( ClassA == -1 && pObj->fMark0 && !pObj->fMark1 )
            {
                if ( fLatchA && !Gia_ObjIsRo(pGia, pObj) )
                    continue;
                ClassA = iObj;
            }
            if ( ClassB == -1 && pObj->fMark1 && !pObj->fMark0 )
            {
                if ( fLatchB && !Gia_ObjIsRo(pGia, pObj) )
                    continue;
                ClassB = iObj;
            }
        }
        // undo equivalence classes
        for ( iObj = i, iNext = Gia_ObjNext(pGia, iObj); iObj;
              iObj = iNext, iNext = Gia_ObjNext(pGia, iObj) )
        {
            Gia_ObjUnsetRepr( pGia, iObj );
            Gia_ObjSetNext( pGia, iObj, 0 );
        }
        assert( !Gia_ObjIsHead(pGia, i) );
        if ( ClassA > 0 && ClassB > 0 )
        {
            if ( ClassA > ClassB )
            {
                ClassA ^= ClassB;
                ClassB ^= ClassA;
                ClassA ^= ClassB;
            }
            assert( ClassA < ClassB );
            Gia_ObjSetNext( pGia, ClassA, ClassB );
            Gia_ObjSetRepr( pGia, ClassB, ClassA );
            Counter++;
            assert( Gia_ObjIsHead(pGia, ClassA) );
        }
    }
    Abc_Print( 1, "The number of two-node classes after filtering = %d.\n", Counter );
//Gia_ManEquivPrintClasses( pGia, 1, 0 );
 
    Gia_ManCleanMark0( pGia );
    Gia_ManCleanMark1( pGia );
    return 1;
}

Here is the call graph for this function:

◆ Gia_ManFilterEquivsUsingLatches()

void Gia_ManFilterEquivsUsingLatches	(	Gia_Man_t *	pGia,
		int	fFlopsOnly,
		int	fFlopsWith,
		int	fUseRiDrivers )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2552 of file giaEquiv.c.

{
    Gia_Obj_t * pObjR;
    Vec_Int_t * vNodes, * vFfIds;
    int i, k, iObj, iNext, iPrev, iRepr;
    int iLitsOld = 0, iLitsNew = 0;
    assert( fFlopsOnly ^ fFlopsWith );
    vNodes = Vec_IntAlloc( 100 );
    // select nodes "flop" node IDs
    vFfIds = Vec_IntStart( Gia_ManObjNum(pGia) );
    if ( fUseRiDrivers )
    {
        Gia_ManForEachRi( pGia, pObjR, i )
            Vec_IntWriteEntry( vFfIds, Gia_ObjFaninId0p(pGia, pObjR), 1 );
    }
    else
    {
        Gia_ManForEachRo( pGia, pObjR, i )
            Vec_IntWriteEntry( vFfIds, Gia_ObjId(pGia, pObjR), 1 );
    }
    // remove all non-flop constants
    Gia_ManForEachConst( pGia, i )
    {
        iLitsOld++;
        assert( pGia->pNexts[i] == 0 );
        if ( !Vec_IntEntry(vFfIds, i) )
            Gia_ObjUnsetRepr( pGia, i );
        else
            iLitsNew++;
    }
    // clear the classes
    if ( fFlopsOnly )
    {
        Gia_ManForEachClass( pGia, i )
        {
            Vec_IntClear( vNodes );
            Gia_ClassForEachObj( pGia, i, iObj )
            {
                if ( Vec_IntEntry(vFfIds, iObj) )
                    Vec_IntPush( vNodes, iObj );
                iLitsOld++;
            }
            iLitsOld--;
            // undo equivalence classes
            for ( iObj = i, iNext = Gia_ObjNext(pGia, iObj); iObj;
                  iObj = iNext, iNext = Gia_ObjNext(pGia, iObj) )
            {
                Gia_ObjUnsetRepr( pGia, iObj );
                Gia_ObjSetNext( pGia, iObj, 0 );
            }
            assert( !Gia_ObjIsHead(pGia, i) );
            if ( Vec_IntSize(vNodes) > 1 )
            {
                // create new class
                iPrev = iRepr = Vec_IntEntry( vNodes, 0 );
                Vec_IntForEachEntryStart( vNodes, iObj, k, 1 )
                {
                    Gia_ObjSetRepr( pGia, iObj, iRepr );
                    Gia_ObjSetNext( pGia, iPrev, iObj );
                    iPrev = iObj;
                    iLitsNew++;
                }
                assert( Gia_ObjNext(pGia, iPrev) == 0 );
            }
        }
    }
    else
    {
        Gia_ManForEachClass( pGia, i )
        {
            int fSeenFlop = 0;
            Gia_ClassForEachObj( pGia, i, iObj )
            {
                if ( Vec_IntEntry(vFfIds, iObj) )
                    fSeenFlop = 1;
                iLitsOld++;
                iLitsNew++;
            }
            iLitsOld--;
            iLitsNew--;
            if ( fSeenFlop )
                continue;
            // undo equivalence classes
            for ( iObj = i, iNext = Gia_ObjNext(pGia, iObj); iObj;
                  iObj = iNext, iNext = Gia_ObjNext(pGia, iObj) )
            {
                Gia_ObjUnsetRepr( pGia, iObj );
                Gia_ObjSetNext( pGia, iObj, 0 );
                iLitsNew--;
            }
            iLitsNew++;
            assert( !Gia_ObjIsHead(pGia, i) );
        }
    }
    Vec_IntFree( vNodes );
    Vec_IntFree( vFfIds );
    Abc_Print( 1, "The number of literals: Before = %d. After = %d.\n", iLitsOld, iLitsNew );
}

◆ Gia_ManFilterEquivsUsingParts()

int Gia_ManFilterEquivsUsingParts	(	Gia_Man_t *	pGia,
		char *	pName1,
		char *	pName2 )

extern

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 2404 of file giaEquiv.c.

{
    Vec_Int_t * vNodes;
    Gia_Man_t * pGia1, * pGia2, * pMiter;
    Gia_Obj_t * pObj1, * pObj2, * pObjM, * pObj = NULL;
    int i, k, iObj, iNext, iPrev, iRepr;
    int iLitsOld, iLitsNew;
    if ( pGia->pReprs == NULL || pGia->pNexts == NULL )
    {
        Abc_Print( 1, "Equivalences are not defined.\n" );
        return 0;
    }
    pGia1 = Gia_AigerRead( pName1, 0, 0, 0 );
    if ( pGia1 == NULL )
    {
        Abc_Print( 1, "Cannot read first file %s.\n", pName1 );
        return 0;
    }
    pGia2 = Gia_AigerRead( pName2, 0, 0, 0 );
    if ( pGia2 == NULL )
    {
        Gia_ManStop( pGia2 );
        Abc_Print( 1, "Cannot read second file %s.\n", pName2 );
        return 0;
    }
    pMiter = Gia_ManMiter( pGia1, pGia2, 0, 0, 1, 0, 0 );
    if ( pMiter == NULL )
    {
        Gia_ManStop( pGia1 );
        Gia_ManStop( pGia2 );
        Abc_Print( 1, "Cannot create sequential miter.\n" );
        return 0;
    }
    // make sure the miter is isomorphic
    if ( Gia_ManObjNum(pGia) != Gia_ManObjNum(pMiter) )
    {
        Gia_ManStop( pGia1 );
        Gia_ManStop( pGia2 );
        Gia_ManStop( pMiter );
        Abc_Print( 1, "The number of objects in different.\n" );
        return 0;
    }
    if ( memcmp( pGia->pObjs, pMiter->pObjs, sizeof(Gia_Obj_t) *  Gia_ManObjNum(pGia) ) )
    {
        Gia_ManStop( pGia1 );
        Gia_ManStop( pGia2 );
        Gia_ManStop( pMiter );
        Abc_Print( 1, "The AIG structure of the miter does not match.\n" );
        return 0;
    }
    // transfer copies
    Gia_ManCleanMark0( pGia );
    Gia_ManForEachObj( pGia1, pObj1, i )
    {
        if ( pObj1->Value == ~0 )
            continue;
        pObjM = Gia_ManObj( pMiter, Abc_Lit2Var(pObj1->Value) );
        pObj = Gia_ManObj( pGia, Gia_ObjId(pMiter, pObjM) );
        pObj->fMark0 = 1;
    }
    Gia_ManCleanMark1( pGia );
    Gia_ManForEachObj( pGia2, pObj2, i )
    {
        if ( pObj2->Value == ~0 )
            continue;
        pObjM = Gia_ManObj( pMiter, Abc_Lit2Var(pObj2->Value) );
        pObj = Gia_ManObj( pGia, Gia_ObjId(pMiter, pObjM) );
        pObj->fMark1 = 1;
    }
 
    // filter equivalences
    iLitsOld = iLitsNew = 0;
    Gia_ManForEachConst( pGia, i )
    {
        iLitsOld++;
        pObj = Gia_ManObj( pGia, i );
        assert( pGia->pNexts[i] == 0 );
        assert( pObj->fMark0 || pObj->fMark1 );
        if ( pObj->fMark0 && pObj->fMark1 ) // belongs to both A and B
            Gia_ObjUnsetRepr( pGia, i );
        else
            iLitsNew++;
    }
    // filter equivalences
    vNodes = Vec_IntAlloc( 100 );
    Gia_ManForEachClass( pGia, i )
    {
        int fSeenA = 0, fSeenB = 0;
        assert( pObj->fMark0 || pObj->fMark1 );
        Vec_IntClear( vNodes );
        Gia_ClassForEachObj( pGia, i, iObj )
        {
            pObj = Gia_ManObj( pGia, iObj );
            if ( pObj->fMark0 && !pObj->fMark1 )
            {
                fSeenA = 1;
                Vec_IntPush( vNodes, iObj );
            }
            if ( !pObj->fMark0 && pObj->fMark1 )
            {
                fSeenB = 1;
                Vec_IntPush( vNodes, iObj );
            }
            iLitsOld++;
        }
        iLitsOld--;
        // undo equivalence classes
        for ( iObj = i, iNext = Gia_ObjNext(pGia, iObj); iObj;
              iObj = iNext, iNext = Gia_ObjNext(pGia, iObj) )
        {
            Gia_ObjUnsetRepr( pGia, iObj );
            Gia_ObjSetNext( pGia, iObj, 0 );
        }
        assert( !Gia_ObjIsHead(pGia, i) );
        if ( fSeenA && fSeenB && Vec_IntSize(vNodes) > 1 )
        {
            // create new class
            iPrev = iRepr = Vec_IntEntry( vNodes, 0 );
            Vec_IntForEachEntryStart( vNodes, iObj, k, 1 )
            {
                Gia_ObjSetRepr( pGia, iObj, iRepr );
                Gia_ObjSetNext( pGia, iPrev, iObj );
                iPrev = iObj;
                iLitsNew++;
            }
            assert( Gia_ObjNext(pGia, iPrev) == 0 );
        }
    }
    Vec_IntFree( vNodes );
    Abc_Print( 1, "The number of literals: Before = %d. After = %d.\n", iLitsOld, iLitsNew );
//Gia_ManEquivPrintClasses( pGia, 1, 0 );
 
    Gia_ManCleanMark0( pGia );
    Gia_ManCleanMark1( pGia );
    return 1;
}

Here is the call graph for this function:

◆ Gia_ManFindFailedPoCex()

int Gia_ManFindFailedPoCex	(	Gia_Man_t *	pAig,
		Abc_Cex_t *	p,
		int	nOutputs )

extern

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

Synopsis [Resimulates the counter-example.]

Description []

SideEffects []

SeeAlso []

Definition at line 91 of file giaCex.c.

{
    Gia_Obj_t * pObj, * pObjRi, * pObjRo;
    int RetValue, i, k, iBit = 0;
    assert( Gia_ManPiNum(pAig) == p->nPis );
    Gia_ManCleanMark0(pAig);
    Gia_ManForEachRo( pAig, pObj, i )
        pObj->fMark0 = Abc_InfoHasBit(p->pData, iBit++);
    iBit = p->nRegs;
    for ( i = 0; i <= p->iFrame; i++ )
    {
        Gia_ManForEachPi( pAig, pObj, k )
            pObj->fMark0 = Abc_InfoHasBit(p->pData, iBit++);
        Gia_ManForEachAnd( pAig, pObj, k )
            pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & 
                           (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
        Gia_ManForEachCo( pAig, pObj, k )
            pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj);
        Gia_ManForEachRiRo( pAig, pObjRi, pObjRo, k )
            pObjRo->fMark0 = pObjRi->fMark0;
    }
    assert( iBit == p->nBits );
    // figure out the number of failed output
    RetValue = -1;
//    for ( i = Gia_ManPoNum(pAig) - 1; i >= nOutputs; i-- )
    for ( i = nOutputs; i < Gia_ManPoNum(pAig); i++ )
    {
        if ( Gia_ManPo(pAig, i)->fMark0 )
        {
            RetValue = i;
            break;
        }
    }
    Gia_ManCleanMark0(pAig);
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManFirstFanouts()

Vec_Int_t * Gia_ManFirstFanouts ( Gia_Man_t * p )

extern

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_ManFraigSweepSimple()

Gia_Man_t * Gia_ManFraigSweepSimple	(	Gia_Man_t *	p,
		void *	pPars )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 606 of file giaSweep.c.

{
    Gia_Man_t * pNew;
    assert( p->pManTime == NULL || Gia_ManBoxNum(p) == 0 );
    Gia_ManFraigSweepPerform( p, pPars );
    pNew = Gia_ManEquivReduce( p, 1, 0, 0, 0 );
    if ( pNew == NULL )
        pNew = Gia_ManDup(p);
    Gia_ManTransferTiming( pNew, p );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManFrames()

Gia_Man_t * Gia_ManFrames	(	Gia_Man_t *	pAig,
		Gia_ParFra_t *	pPars )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 840 of file giaFrames.c.

{
    Gia_Man_t * pFrames, * pTemp;
    Gia_Obj_t * pObj;
    Vec_Int_t * vPoLits = NULL;
    int i, f;
    assert( Gia_ManRegNum(pAig) > 0 );
    assert( pPars->nFrames > 0 );
    if ( pPars->fInit )
        return Gia_ManFramesInit( pAig, pPars );
    if ( pPars->fOrPos )
        vPoLits = Vec_IntStart( Gia_ManPoNum(pAig) );
    pFrames = Gia_ManStart( pPars->nFrames * Gia_ManObjNum(pAig) );
    pFrames->pName = Abc_UtilStrsav( pAig->pName );
    pFrames->pSpec = Abc_UtilStrsav( pAig->pSpec );
    if ( !pPars->fDisableSt )
        Gia_ManHashAlloc( pFrames );
    Gia_ManConst0(pAig)->Value = 0;
    // create primary inputs
    for ( f = 0; f < pPars->nFrames; f++ )
        Gia_ManForEachPi( pAig, pObj, i )
            pObj->Value = Gia_ManAppendCi( pFrames );
    // add internal nodes for each timeframe
    for ( f = 0; f < pPars->nFrames; f++ )
    {
        if ( f == 0 )
        {
            Gia_ManForEachRo( pAig, pObj, i )
                pObj->Value = Gia_ManAppendCi( pFrames );
        }
        else
        {
            Gia_ManForEachRo( pAig, pObj, i )
                pObj->Value = Gia_ObjRoToRi( pAig, pObj )->Value;
        }
        Gia_ManForEachPi( pAig, pObj, i )
            pObj->Value = Gia_Obj2Lit( pFrames, Gia_ManPi(pFrames, f * Gia_ManPiNum(pAig) + i) );
        if ( !pPars->fDisableSt )
            Gia_ManForEachAnd( pAig, pObj, i )
                pObj->Value = Gia_ManHashAnd( pFrames, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else
            Gia_ManForEachAnd( pAig, pObj, i )
                pObj->Value = Gia_ManAppendAnd2( pFrames, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        if ( vPoLits )
        {
            if ( !pPars->fDisableSt )
                Gia_ManForEachPo( pAig, pObj, i )
                    Vec_IntWriteEntry( vPoLits, i, Gia_ManHashOr(pFrames, Vec_IntEntry(vPoLits, i), Gia_ObjFanin0Copy(pObj)) );
            else
                Gia_ManForEachPo( pAig, pObj, i )
                    Vec_IntWriteEntry( vPoLits, i, Abc_LitNot(Gia_ManAppendAnd2(pFrames, Abc_LitNot(Vec_IntEntry(vPoLits, i)), Abc_LitNot(Gia_ObjFanin0Copy(pObj)))) );
        }
        else
        {
            Gia_ManForEachPo( pAig, pObj, i )
                pObj->Value = Gia_ManAppendCo( pFrames, Gia_ObjFanin0Copy(pObj) );
        }
        if ( f == pPars->nFrames - 1 )
        {
            if ( vPoLits )
                Gia_ManForEachPo( pAig, pObj, i )
                    pObj->Value = Gia_ManAppendCo( pFrames, Vec_IntEntry(vPoLits, i) );
            Gia_ManForEachRi( pAig, pObj, i )
                pObj->Value = Gia_ManAppendCo( pFrames, Gia_ObjFanin0Copy(pObj) );
        }
        else
        {
            Gia_ManForEachRi( pAig, pObj, i )
                pObj->Value = Gia_ObjFanin0Copy(pObj);
        }
    }
    Vec_IntFreeP( &vPoLits );
    if ( !pPars->fDisableSt )
        Gia_ManHashStop( pFrames );
    Gia_ManSetRegNum( pFrames, Gia_ManRegNum(pAig) );
    if ( Gia_ManCombMarkUsed(pFrames) < Gia_ManAndNum(pFrames) )
    {
        pFrames = Gia_ManDupMarked( pTemp = pFrames );
        if ( pPars->fVerbose )
            printf( "Before cleanup = %d nodes. After cleanup = %d nodes.\n", 
                Gia_ManAndNum(pTemp), Gia_ManAndNum(pFrames) );
        Gia_ManStop( pTemp );
    }
    else if ( pPars->fVerbose )
            printf( "Before cleanup = %d nodes. After cleanup = %d nodes.\n", 
                Gia_ManAndNum(pFrames), Gia_ManAndNum(pFrames) );
    return pFrames;
}

Here is the call graph for this function:

◆ Gia_ManFramesInitSpecial()

Gia_Man_t * Gia_ManFramesInitSpecial	(	Gia_Man_t *	pAig,
		int	nFrames,
		int	fVerbose )

extern

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

Synopsis [Perform init unrolling as long as PO(s) are constant 0.]

Description []

SideEffects []

SeeAlso []

Definition at line 941 of file giaFrames.c.

{
    Gia_Man_t * pFrames, * pTemp;
    Gia_Obj_t * pObj;
    int i, f;
    assert( Gia_ManRegNum(pAig) > 0 );
    if ( nFrames > 0 )
        printf( "Computing specialized unrolling with %d frames...\n", nFrames );
    pFrames = Gia_ManStart( Gia_ManObjNum(pAig) );
    pFrames->pName = Abc_UtilStrsav( pAig->pName );
    pFrames->pSpec = Abc_UtilStrsav( pAig->pSpec );
    Gia_ManHashAlloc( pFrames );
    Gia_ManConst0(pAig)->Value = 0;
    for ( f = 0; nFrames == 0 || f < nFrames; f++ )
    {
        if ( fVerbose && (f % 100 == 0) )
        {
            printf( "%6d : ", f );
            Gia_ManPrintStats( pFrames, NULL );
        }
        Gia_ManForEachRo( pAig, pObj, i )
            pObj->Value = f ? Gia_ObjRoToRi( pAig, pObj )->Value : 0;
        Gia_ManForEachPi( pAig, pObj, i )
            pObj->Value = Gia_ManAppendCi( pFrames );
        Gia_ManForEachAnd( pAig, pObj, i )
            pObj->Value = Gia_ManHashAnd( pFrames, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        Gia_ManForEachPo( pAig, pObj, i )
            if ( Gia_ObjFanin0Copy(pObj) != 0 )
                break;
        if ( i < Gia_ManPoNum(pAig) )
            break;
        Gia_ManForEachRi( pAig, pObj, i )
            pObj->Value = Gia_ObjFanin0Copy(pObj);
    }
    if ( fVerbose )
        printf( "Computed prefix of %d frames.\n", f );
    Gia_ManForEachRi( pAig, pObj, i )
        Gia_ManAppendCo( pFrames, pObj->Value );
    Gia_ManHashStop( pFrames );
    pFrames = Gia_ManCleanup( pTemp = pFrames );
    if ( fVerbose )
        printf( "Before cleanup = %d nodes. After cleanup = %d nodes.\n", 
            Gia_ManAndNum(pTemp), Gia_ManAndNum(pFrames) );
    Gia_ManStop( pTemp );
    return pFrames;
}

Here is the call graph for this function:

◆ Gia_ManFraSetDefaultParams()

void Gia_ManFraSetDefaultParams ( Gia_ParFra_t * p )

extern

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

Synopsis [This procedure sets default parameters.]

Description []

SideEffects []

SeeAlso []

Definition at line 631 of file giaFrames.c.

{
    memset( p, 0, sizeof(Gia_ParFra_t) );
    p->nFrames      =  32;    // the number of frames to unroll
    p->fInit        =   0;    // initialize the timeframes
    p->fVerbose     =   0;    // enables verbose output
}

Here is the call graph for this function:

◆ Gia_ManFront()

Gia_Man_t * Gia_ManFront ( Gia_Man_t * p )

extern

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

Synopsis [Determine the frontier.]

Description []

SideEffects []

SeeAlso []

Definition at line 147 of file giaFront.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj, * pFanin0New, * pFanin1New, * pObjNew;
    char * pFront;    // places used for the frontier
    int i, iLit, nCrossCut = 0, nCrossCutMax = 0;
    int nCrossCutMaxInit = Gia_ManCrossCutSimple( p );
    int iFront = 0;//, clk = Abc_Clock(); 
    // set references for all objects
    Gia_ManCreateValueRefs( p );
    // start the new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->nFront = 1 + (int)((float)1.1 * nCrossCutMaxInit); 
    // start the frontier
    pFront = ABC_CALLOC( char, pNew->nFront );
    // add constant node
    Gia_ManConst0(pNew)->Value = iFront = Gia_ManFrontFindNext( pFront, pNew->nFront, iFront );
    if ( Gia_ObjValue(Gia_ManConst0(p)) == 0 )
        pFront[iFront] = 0;
    else
        nCrossCut = 1;
    // iterate through the objects
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
        {
            if ( Gia_ObjValue(pObj) && nCrossCutMax < ++nCrossCut )
                nCrossCutMax = nCrossCut;
            // create new node
            iLit = Gia_ManAppendCi( pNew );
            pObjNew = Gia_ManObj( pNew, Abc_Lit2Var(iLit) );
            assert( Gia_ObjId(pNew, pObjNew) == Gia_ObjId(p, pObj) );
            pObjNew->Value = iFront = Gia_ManFrontFindNext( pFront, pNew->nFront, iFront );
            // handle CIs without fanout
            if ( Gia_ObjValue(pObj) == 0 )
                pFront[iFront] = 0;
            continue;
        }
        if ( Gia_ObjIsCo(pObj) )
        {
            assert( Gia_ObjValue(pObj) == 0 );
            // create new node
            iLit = Gia_ManAppendCo( pNew, 0 );
            pObjNew = Gia_ManObj( pNew, Abc_Lit2Var(iLit) );
            assert( Gia_ObjId(pNew, pObjNew) == Gia_ObjId(p, pObj) );
            // get the fanin
            pFanin0New = Gia_ManObj( pNew, Gia_ObjFaninId0(pObj, i) );
            assert( pFanin0New->Value != GIA_NONE );
            pObjNew->Value = GIA_NONE;
            pObjNew->iDiff0 = pFanin0New->Value;
            pObjNew->fCompl0 = Gia_ObjFaninC0(pObj);
            // deref the fanin
            if ( --Gia_ObjFanin0(pObj)->Value == 0 )
            {
                pFront[pFanin0New->Value] = 0;
                nCrossCut--;
            }
            continue;
        }
        if ( Gia_ObjValue(pObj) && nCrossCutMax < ++nCrossCut )
            nCrossCutMax = nCrossCut;
        // create new node
        pObjNew = Gia_ManAppendObj( pNew );
        assert( Gia_ObjId(pNew, pObjNew) == Gia_ObjId(p, pObj) );
        // assign the first fanin
        pFanin0New = Gia_ManObj( pNew, Gia_ObjFaninId0(pObj, i) );
        assert( pFanin0New->Value != GIA_NONE );
        pObjNew->iDiff0 = pFanin0New->Value;
        pObjNew->fCompl0 = Gia_ObjFaninC0(pObj);
        // assign the second fanin
        pFanin1New = Gia_ManObj( pNew, Gia_ObjFaninId1(pObj, i) );
        assert( pFanin1New->Value != GIA_NONE );
        pObjNew->iDiff1 = pFanin1New->Value;
        pObjNew->fCompl1 = Gia_ObjFaninC1(pObj);
        // assign the frontier number
        pObjNew->Value = iFront = Gia_ManFrontFindNext( pFront, pNew->nFront, iFront );
        // deref the fanins
        if ( --Gia_ObjFanin0(pObj)->Value == 0 )
        {
            pFront[pFanin0New->Value] = 0;
            nCrossCut--;
        }
        if ( --Gia_ObjFanin1(pObj)->Value == 0 )
        {
            pFront[pFanin1New->Value] = 0;
            nCrossCut--;
        }
        // handle nodes without fanout (choice nodes)
        if ( Gia_ObjValue(pObj) == 0 )
            pFront[iFront] = 0;
    }
    assert( pNew->nObjs == p->nObjs );
    assert( nCrossCut == 0 || nCrossCutMax == nCrossCutMaxInit );
    for ( i = 0; i < pNew->nFront; i++ )
        assert( pFront[i] == 0 );
    ABC_FREE( pFront );
//printf( "Crosscut = %6d. Frontier = %6d. ", nCrossCutMaxInit, pNew->nFront );
//ABC_PRT( "Time", Abc_Clock() - clk );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManFrontTest()

void Gia_ManFrontTest ( Gia_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 262 of file giaFront.c.

{
    Gia_Man_t * pNew;
    pNew  = Gia_ManFront( p );
    Gia_ManFrontTransform( pNew );
//    Gia_ManCleanValue( p );
//    Gia_ManCleanValue( pNew );
    if ( memcmp( pNew->pObjs, p->pObjs, sizeof(Gia_Obj_t) * p->nObjs ) )
    {
/*
        Gia_Obj_t * pObj, * pObjNew;
        int i;
        Gia_ManForEachObj( p, pObj, i )
        {
            pObjNew = Gia_ManObj( pNew, i );
            printf( "%5d %5d   %5d %5d\n", 
                pObj->iDiff0, pObjNew->iDiff0, 
                pObj->iDiff1, pObjNew->iDiff1 );
        }
*/
        printf( "Verification failed.\n" );
    }
    else
        printf( "Verification successful.\n" );
    Gia_ManStop( pNew );
}

Here is the call graph for this function:

◆ Gia_ManGetCiLevels()

Vec_Int_t * Gia_ManGetCiLevels ( Gia_Man_t * p )

extern

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 )

extern

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_ManHasDangling()

int Gia_ManHasDangling ( Gia_Man_t * p )

extern

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_ManHashAlloc()

void Gia_ManHashAlloc ( Gia_Man_t * p )

extern

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

Synopsis [Starts the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 105 of file giaHash.c.

{
    assert( Vec_IntSize(&p->vHTable) == 0 );
    Vec_IntFill( &p->vHTable, Abc_PrimeCudd( Gia_ManAndNum(p) ? Gia_ManAndNum(p) + 1000 : p->nObjsAlloc ), 0 );
    Vec_IntGrow( &p->vHash, Abc_MaxInt(Vec_IntSize(&p->vHTable), Gia_ManObjNum(p)) );
    Vec_IntFill( &p->vHash, Gia_ManObjNum(p), 0 );
//printf( "Alloced table with %d entries.\n", Vec_IntSize(&p->vHTable) );
}

◆ Gia_ManHashAnd()

int Gia_ManHashAnd	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

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

Synopsis [Hashes AND gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 576 of file giaHash.c.

{ 
    if ( iLit0 < 2 )
        return iLit0 ? iLit1 : 0;
    if ( iLit1 < 2 )
        return iLit1 ? iLit0 : 0;
    if ( iLit0 == iLit1 )
        return iLit1;
    if ( iLit0 == Abc_LitNot(iLit1) )
        return 0;
    if ( p->fGiaSimple )
    {
        assert( Vec_IntSize(&p->vHTable) == 0 );
        return Gia_ManAppendAnd( p, iLit0, iLit1 );
    }
    if ( (p->nObjs & 0xFF) == 0 && 2 * Vec_IntSize(&p->vHTable) < Gia_ManAndNum(p) )
        Gia_ManHashResize( p );
    if ( p->fAddStrash )
    {
        Gia_Obj_t * pObj = Gia_ManAddStrash( p, Gia_ObjFromLit(p, iLit0), Gia_ObjFromLit(p, iLit1) );
        if ( pObj != NULL )
            return Gia_ObjToLit( p, pObj );
    }
    if ( iLit0 > iLit1 )
        iLit0 ^= iLit1, iLit1 ^= iLit0, iLit0 ^= iLit1;
    {
        int * pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
        if ( *pPlace )
        {
            p->nHashHit++;
            return Abc_Var2Lit( *pPlace, 0 );
        }
        p->nHashMiss++;
        if ( Vec_IntSize(&p->vHash) < Vec_IntCap(&p->vHash) )
            *pPlace = Abc_Lit2Var( Gia_ManAppendAnd( p, iLit0, iLit1 ) );
        else
        {
            int iNode = Gia_ManAppendAnd( p, iLit0, iLit1 );
            pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
            assert( *pPlace == 0 );
            *pPlace = Abc_Lit2Var( iNode );
        }
        return Abc_Var2Lit( *pPlace, 0 );
    }
}

Here is the call graph for this function:

◆ Gia_ManHashAndMulti()

int Gia_ManHashAndMulti	(	Gia_Man_t *	p,
		Vec_Int_t *	vLits )

extern

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

Synopsis [Creates well-balanced AND gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 783 of file giaHash.c.

{
    if ( Vec_IntSize(vLits) == 0 )
        return 0;
    while ( Vec_IntSize(vLits) > 1 )
    {
        int i, k = 0, Lit1, Lit2, LitRes;
        Vec_IntForEachEntryDouble( vLits, Lit1, Lit2, i )
        {
            LitRes = Gia_ManHashAnd( p, Lit1, Lit2 );
            Vec_IntWriteEntry( vLits, k++, LitRes );
        }
        if ( Vec_IntSize(vLits) & 1 )
            Vec_IntWriteEntry( vLits, k++, Vec_IntEntryLast(vLits) );
        Vec_IntShrink( vLits, k );
    }
    assert( Vec_IntSize(vLits) == 1 );
    return Vec_IntEntry(vLits, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManHashAndMulti2()

int Gia_ManHashAndMulti2	(	Gia_Man_t *	p,
		Vec_Int_t *	vLits )

extern

Definition at line 802 of file giaHash.c.

{
    int i, iLit, iRes = 1;
    Vec_IntForEachEntry( vLits, iLit, i )
        iRes = Gia_ManHashAnd( p, iRes, iLit );
    return iRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManHashAndTry()

int Gia_ManHashAndTry	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 637 of file giaHash.c.

{ 
    if ( iLit0 < 2 )
        return iLit0 ? iLit1 : 0;
    if ( iLit1 < 2 )
        return iLit1 ? iLit0 : 0;
    if ( iLit0 == iLit1 )
        return iLit1;
    if ( iLit0 == Abc_LitNot(iLit1) )
        return 0;
    if ( iLit0 > iLit1 )
        iLit0 ^= iLit1, iLit1 ^= iLit0, iLit0 ^= iLit1;
    {
        int * pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
        if ( *pPlace ) 
            return Abc_Var2Lit( *pPlace, 0 );
        return -1;
    }
}

Here is the caller graph for this function:

◆ Gia_ManHashDualMiter()

int Gia_ManHashDualMiter	(	Gia_Man_t *	p,
		Vec_Int_t *	vOuts )

extern

Definition at line 809 of file giaHash.c.

{
    int i, iLit0, iLit1, iRes = 0;
    Vec_IntForEachEntryDouble( vOuts, iLit0, iLit1, i )
        iRes = Gia_ManHashOr( p, iRes, Gia_ManHashXor(p, iLit0, iLit1) );
    return iRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManHashLookup()

int Gia_ManHashLookup	(	Gia_Man_t *	p,
		Gia_Obj_t *	p0,
		Gia_Obj_t *	p1 )

extern

Definition at line 87 of file giaHash.c.

{
    int iLit0 = Gia_ObjToLit( p, p0 );
    int iLit1 = Gia_ObjToLit( p, p1 );
    return Gia_ManHashLookupInt( p, iLit0, iLit1 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManHashLookupInt()

int Gia_ManHashLookupInt	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 81 of file giaHash.c.

{
    if ( iLit0 > iLit1 )
        iLit0 ^= iLit1, iLit1 ^= iLit0, iLit0 ^= iLit1;
    return Abc_Var2Lit( *Gia_ManHashFind( p, iLit0, iLit1, -1 ), 0 );
}

Here is the caller graph for this function:

◆ Gia_ManHashMaj()

int Gia_ManHashMaj	(	Gia_Man_t *	p,
		int	iData0,
		int	iData1,
		int	iData2 )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 720 of file giaHash.c.

{ 
    int iTemp0 = Gia_ManHashOr( p, iData1, iData2 );
    int iTemp1 = Gia_ManHashAnd( p, iData0, iTemp0 );
    int iTemp2 = Gia_ManHashAnd( p, iData1, iData2 );
    return Gia_ManHashOr( p, iTemp1, iTemp2 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManHashMux()

int Gia_ManHashMux	(	Gia_Man_t *	p,
		int	iCtrl,
		int	iData1,
		int	iData0 )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 692 of file giaHash.c.

{ 
    if ( p->fGiaSimple )
        return Gia_ManHashOr(p, Gia_ManHashAnd(p, iCtrl, iData1), Gia_ManHashAnd(p, Abc_LitNot(iCtrl), iData0) );
    else
    {
        int iTemp0, iTemp1, fCompl = 0;
        if ( iData0 > iData1 )
            iData0 ^= iData1, iData1 ^= iData0, iData0 ^= iData1, iCtrl = Abc_LitNot(iCtrl);
        if ( Abc_LitIsCompl(iData1) )
            iData0 = Abc_LitNot(iData0), iData1 = Abc_LitNot(iData1), fCompl = 1;
        iTemp0 = Gia_ManHashAnd( p, Abc_LitNot(iCtrl), iData0 );
        iTemp1 = Gia_ManHashAnd( p, iCtrl, iData1 );
        return Abc_LitNotCond( Gia_ManHashAnd( p, Abc_LitNot(iTemp0), Abc_LitNot(iTemp1) ), !fCompl );
    }
}

Here is the call graph for this function:

◆ Gia_ManHashMuxReal()

int Gia_ManHashMuxReal	(	Gia_Man_t *	p,
		int	iLitC,
		int	iLit1,
		int	iLit0 )

extern

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

Synopsis [Hashes MUX gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 521 of file giaHash.c.

{
    int fCompl = 0;
    assert( p->fAddStrash == 0 );
    if ( iLitC < 2 )
        return iLitC ? iLit1 : iLit0;
    if ( iLit0 < 2 )
        return iLit0 ? Gia_ManHashOr(p, Abc_LitNot(iLitC), iLit1) : Gia_ManHashAnd(p, iLitC, iLit1);
    if ( iLit1 < 2 )
        return iLit1 ? Gia_ManHashOr(p, iLitC, iLit0) : Gia_ManHashAnd(p, Abc_LitNot(iLitC), iLit0);
    assert( iLit0 > 1 && iLit1 > 1 && iLitC > 1 );
    if ( iLit0 == iLit1 )
        return iLit0;
    if ( iLitC == iLit0 || iLitC == Abc_LitNot(iLit1) )
        return Gia_ManHashAnd(p, iLit0, iLit1);
    if ( iLitC == iLit1 || iLitC == Abc_LitNot(iLit0) )
        return Gia_ManHashOr(p, iLit0, iLit1);
    if ( Abc_Lit2Var(iLit0) == Abc_Lit2Var(iLit1) )
        return Gia_ManHashXorReal( p, iLitC, iLit0 );
    if ( iLit0 > iLit1 )
        iLit0 ^= iLit1, iLit1 ^= iLit0, iLit0 ^= iLit1, iLitC = Abc_LitNot(iLitC);
    if ( Abc_LitIsCompl(iLit1) )
        iLit0 = Abc_LitNot(iLit0), iLit1 = Abc_LitNot(iLit1), fCompl = 1;
    {
        int *pPlace = Gia_ManHashFind( p, iLit0, iLit1, iLitC );
        if ( *pPlace )
        {
            p->nHashHit++;
            return Abc_Var2Lit( *pPlace, fCompl );
        }
        p->nHashMiss++;
        if ( Vec_IntSize(&p->vHash) < Vec_IntCap(&p->vHash) )
            *pPlace = Abc_Lit2Var( Gia_ManAppendMuxReal( p, iLitC, iLit1, iLit0 ) );
        else
        {
            int iNode = Gia_ManAppendMuxReal( p, iLitC, iLit1, iLit0 );
            pPlace = Gia_ManHashFind( p, iLit0, iLit1, iLitC );
            assert( *pPlace == 0 );
            *pPlace = Abc_Lit2Var( iNode );
        }
        return Abc_Var2Lit( *pPlace, fCompl );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManHashOr()

int Gia_ManHashOr	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 621 of file giaHash.c.

{ 
    return Abc_LitNot(Gia_ManHashAnd( p, Abc_LitNot(iLit0), Abc_LitNot(iLit1) ));
}

Here is the call graph for this function:

◆ Gia_ManHashProfile()

void Gia_ManHashProfile ( Gia_Man_t * p )

extern

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

Synopsis [Profiles the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 207 of file giaHash.c.

{
    int iEntry;
    int i, Counter, Limit;
    printf( "Table size = %d. Entries = %d. ", Vec_IntSize(&p->vHTable), Gia_ManAndNum(p) );
    printf( "Hits = %d. Misses = %d.\n", (int)p->nHashHit, (int)p->nHashMiss );
    Limit = Abc_MinInt( 1000, Vec_IntSize(&p->vHTable) );
    for ( i = 0; i < Limit; i++ )
    {
        Counter = 0;
        for ( iEntry = Vec_IntEntry(&p->vHTable, i); 
              iEntry; 
              iEntry = iEntry? Vec_IntEntry(&p->vHash, iEntry) : 0 )
            Counter++;
        if ( Counter ) 
            printf( "%d ", Counter );
    }
    printf( "\n" );
}

◆ Gia_ManHashStart()

void Gia_ManHashStart ( Gia_Man_t * p )

extern

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

Synopsis [Starts the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 125 of file giaHash.c.

{
    Gia_Obj_t * pObj;
    int * pPlace, i;
    Gia_ManHashAlloc( p );
    Gia_ManForEachAnd( p, pObj, i )
    {
        pPlace = Gia_ManHashFind( p, Gia_ObjFaninLit0(pObj, i), Gia_ObjFaninLit1(pObj, i), Gia_ObjFaninLit2(p, i) );
        assert( *pPlace == 0 );
        *pPlace = i;
    }
}

Here is the call graph for this function:

◆ Gia_ManHashStop()

void Gia_ManHashStop ( Gia_Man_t * p )

extern

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

Synopsis [Stops the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 149 of file giaHash.c.

{
    Vec_IntErase( &p->vHTable );
    Vec_IntErase( &p->vHash );
}

◆ Gia_ManHashXor()

int Gia_ManHashXor	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 668 of file giaHash.c.

{ 
    if ( p->fGiaSimple )
        return Gia_ManHashOr(p, Gia_ManHashAnd(p, iLit0, Abc_LitNot(iLit1)), Gia_ManHashAnd(p, Abc_LitNot(iLit0), iLit1) );
    else
    {
        int fCompl = Abc_LitIsCompl(iLit0) ^ Abc_LitIsCompl(iLit1);
        int iTemp0 = Gia_ManHashAnd( p, Abc_LitRegular(iLit0), Abc_LitNot(Abc_LitRegular(iLit1)) );
        int iTemp1 = Gia_ManHashAnd( p, Abc_LitRegular(iLit1), Abc_LitNot(Abc_LitRegular(iLit0)) );
        return Abc_LitNotCond( Gia_ManHashAnd( p, Abc_LitNot(iTemp0), Abc_LitNot(iTemp1) ), !fCompl );
    }
}

Here is the call graph for this function:

◆ Gia_ManHashXorReal()

int Gia_ManHashXorReal	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

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

Synopsis [Hashes XOR gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 469 of file giaHash.c.

{ 
    int fCompl = 0;
    assert( p->fAddStrash == 0 );
    if ( iLit0 < 2 )
        return iLit0 ? Abc_LitNot(iLit1) : iLit1;
    if ( iLit1 < 2 )
        return iLit1 ? Abc_LitNot(iLit0) : iLit0;
    if ( iLit0 == iLit1 )
        return 0;
    if ( iLit0 == Abc_LitNot(iLit1) )
        return 1;
    if ( (p->nObjs & 0xFF) == 0 && 2 * Vec_IntSize(&p->vHTable) < Gia_ManAndNum(p) )
        Gia_ManHashResize( p );
    if ( iLit0 < iLit1 )
        iLit0 ^= iLit1, iLit1 ^= iLit0, iLit0 ^= iLit1;
    if ( Abc_LitIsCompl(iLit0) )
        iLit0 = Abc_LitNot(iLit0), fCompl ^= 1;
    if ( Abc_LitIsCompl(iLit1) )
        iLit1 = Abc_LitNot(iLit1), fCompl ^= 1;
    {
        int *pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
        if ( *pPlace )
        {
            p->nHashHit++;
            return Abc_Var2Lit( *pPlace, fCompl );
        }
        p->nHashMiss++;
        if ( Vec_IntSize(&p->vHash) < Vec_IntCap(&p->vHash) )
            *pPlace = Abc_Lit2Var( Gia_ManAppendXorReal( p, iLit0, iLit1 ) );
        else
        {
            int iNode = Gia_ManAppendXorReal( p, iLit0, iLit1 );
            pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
            assert( *pPlace == 0 );
            *pPlace = Abc_Lit2Var( iNode );
        }
        return Abc_Var2Lit( *pPlace, fCompl );
    }
}

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 )

extern

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_ManIncrSimCheckEqual()

int Gia_ManIncrSimCheckEqual	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 1214 of file giaSim.c.

{
    assert( iLit0 > 1 && iLit1 > 1 );
    Gia_ManIncrSimUpdate( p );
    Gia_ManIncrSimCone_rec( p, Abc_Lit2Var(iLit0) );
    Gia_ManIncrSimCone_rec( p, Abc_Lit2Var(iLit1) );
//    return 1; // disable
    return Gia_ManBuiltInSimCheckEqual( p, iLit0, iLit1 );
}

Here is the call graph for this function:

◆ Gia_ManIncrSimCheckOver()

int Gia_ManIncrSimCheckOver	(	Gia_Man_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 1205 of file giaSim.c.

{
    assert( iLit0 > 1 && iLit1 > 1 );
    Gia_ManIncrSimUpdate( p );
    Gia_ManIncrSimCone_rec( p, Abc_Lit2Var(iLit0) );
    Gia_ManIncrSimCone_rec( p, Abc_Lit2Var(iLit1) );
//    return 0; // disable
    return Gia_ManBuiltInSimCheckOver( p, iLit0, iLit1 );
}

Here is the call graph for this function:

◆ Gia_ManIncrSimSet()

void Gia_ManIncrSimSet	(	Gia_Man_t *	p,
		Vec_Int_t *	vObjLits )

extern

Definition at line 1174 of file giaSim.c.

{
    int i, iLit; 
    assert( Vec_IntSize(vObjLits) > 0 );
    p->iTimeStamp++;
    Vec_IntForEachEntry( vObjLits, iLit, i )
    {
        word * pSims = Gia_ManBuiltInData( p, Abc_Lit2Var(iLit) );
        if ( Gia_ObjIsAnd(Gia_ManObj(p, Abc_Lit2Var(iLit))) )
            continue;
        //assert( Vec_IntEntry(p->vTimeStamps, Abc_Lit2Var(iLit)) == p->iTimeStamp-1 );
        Vec_IntWriteEntry(p->vTimeStamps, Abc_Lit2Var(iLit), p->iTimeStamp);
        if ( Abc_TtGetBit(pSims, p->iPatsPi) == Abc_LitIsCompl(iLit) )
             Abc_TtXorBit(pSims, p->iPatsPi);
    }
    p->iPatsPi = (p->iPatsPi == p->nSimWords * 64 - 1) ? 0 : p->iPatsPi + 1;
}

◆ Gia_ManIncrSimStart()

void Gia_ManIncrSimStart	(	Gia_Man_t *	p,
		int	nWords,
		int	nObjs )

extern

Definition at line 1150 of file giaSim.c.

{
    assert( !p->fIncrSim );
    p->fIncrSim  = 1;
    p->iPatsPi   = 0;
    p->nSimWords = nWords;
    // init time stamps
    p->iTimeStamp  = 1;
    p->vTimeStamps = Vec_IntAlloc( p->nSimWords );
    // init object sim info
    p->iNextPi = 0;       
    p->vSims   = Vec_WrdAlloc( p->nSimWords * nObjs );
    Gia_ManRandomW( 1 );
}

Here is the call graph for this function:

◆ Gia_ManInvertConstraints()

void Gia_ManInvertConstraints ( Gia_Man_t * pAig )

extern

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 )

extern

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_ManIsNormalized()

int Gia_ManIsNormalized ( Gia_Man_t * p )

extern

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

Synopsis [Makes sure the manager is normalized.]

Description []

SideEffects []

SeeAlso []

Definition at line 114 of file giaTim.c.

{
    int i, nOffset;
    nOffset = 1;
    for ( i = 0; i < Gia_ManCiNum(p); i++ )
        if ( !Gia_ObjIsCi( Gia_ManObj(p, nOffset+i) ) )
            return 0;
    nOffset = 1 + Gia_ManCiNum(p) + Gia_ManAndNum(p);
    for ( i = 0; i < Gia_ManCoNum(p); i++ )
        if ( !Gia_ObjIsCo( Gia_ManObj(p, nOffset+i) ) )
            return 0;
    return 1;
}

Here is the caller graph for this function:

◆ Gia_ManIsoCanonicize()

Gia_Man_t * Gia_ManIsoCanonicize	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 958 of file giaIso.c.

{
    Gia_Man_t * pRes = NULL;
    Vec_Int_t * vCis, * vAnds, * vCos;
    Vec_Ptr_t * vEquiv;
    if ( Gia_ManCiNum(p) == 0 ) // const AIG
    {
        assert( Gia_ManPoNum(p) == 1 );
        assert( Gia_ManObjNum(p) == 2 );
        return Gia_ManDup(p);
    }
    // derive canonical values
    vEquiv = Gia_IsoDeriveEquivPos( p, 0, fVerbose );
    Vec_VecFreeP( (Vec_Vec_t **)&vEquiv );
    // find canonical order of CIs/COs/nodes
    // find canonical order
    vCis  = Vec_IntAlloc( Gia_ManCiNum(p) );
    vAnds = Vec_IntAlloc( Gia_ManAndNum(p) );
    vCos  = Vec_IntAlloc( Gia_ManCoNum(p) );
    Gia_ManFindCaninicalOrder( p, vCis, vAnds, vCos, NULL );
    // derive the new AIG
    pRes = Gia_ManDupFromVecs( p, vCis, vAnds, vCos, Gia_ManRegNum(p) );
    // cleanup
    Vec_IntFree( vCis );
    Vec_IntFree( vAnds );
    Vec_IntFree( vCos );
    return pRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManIsoReduce()

Gia_Man_t * Gia_ManIsoReduce	(	Gia_Man_t *	pInit,
		Vec_Ptr_t **	pvPosEquivs,
		Vec_Ptr_t **	pvPiPerms,
		int	fEstimate,
		int	fDualOut,
		int	fVerbose,
		int	fVeryVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1075 of file giaIso.c.

{ 
    Gia_Man_t * p, * pPart;
    Vec_Ptr_t * vEquivs, * vEquivs2, * vStrings;
    Vec_Int_t * vRemain, * vLevel, * vLevel2;
    Vec_Str_t * vStr, * vStr2;
    int i, k, s, sStart, iPo, Counter;
    int nClasses, nUsedPos;
    abctime clk = Abc_Clock();
    if ( pvPosEquivs )
        *pvPosEquivs = NULL;
    if ( pvPiPerms )
        *pvPiPerms = Vec_PtrStart( Gia_ManPoNum(pInit) );
 
    if ( fDualOut )
    {
        assert( (Gia_ManPoNum(pInit) & 1) == 0 );
        if ( Gia_ManPoNum(pInit) == 2 )
            return Gia_ManDup(pInit);
        p = Gia_ManTransformMiter( pInit );
        p = Gia_ManSeqStructSweep( pPart = p, 1, 1, 0 );
        Gia_ManStop( pPart );
    }
    else
    {
        if ( Gia_ManPoNum(pInit) == 1 )
            return Gia_ManDup(pInit);
        p = pInit;
    }
 
    // create preliminary equivalences
    vEquivs = Gia_IsoDeriveEquivPos( p, 1, fVeryVerbose );
    if ( vEquivs == NULL )
    {
        if ( fDualOut )
            Gia_ManStop( p );
        return NULL;
    }
    nClasses = Vec_IntCountNonTrivial( vEquivs, &nUsedPos );
    printf( "Reduced %d outputs to %d candidate   classes (%d outputs are in %d non-trivial classes).  ", 
        Gia_ManPoNum(p), Vec_PtrSize(vEquivs), nUsedPos, nClasses );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    if ( fEstimate )
    {
        Vec_VecFree( (Vec_Vec_t *)vEquivs );
        return Gia_ManDup(pInit);
    }
 
    // perform refinement of equivalence classes
    Counter = 0;
    vEquivs2 = Vec_PtrAlloc( 100 );
    Vec_PtrForEachEntry( Vec_Int_t *, vEquivs, vLevel, i )
    {
        if ( Vec_IntSize(vLevel) < 2 )
        {
            Vec_PtrPush( vEquivs2, Vec_IntDup(vLevel) );
            for ( k = 0; k < Vec_IntSize(vLevel); k++ )
                if ( ++Counter % 100 == 0 )
                    printf( "%6d finished...\r", Counter );
            continue;
        }
 
        if ( fVerbose )
        {
            iPo = Vec_IntEntry(vLevel, 0);
            printf( "%6d %6d %6d : ", i, Vec_IntSize(vLevel), iPo );
            pPart = Gia_ManDupCones( p, &iPo, 1, 1 );
            Gia_ManPrintStats(pPart, NULL);
            Gia_ManStop( pPart );
        }
 
        sStart = Vec_PtrSize( vEquivs2 ); 
        vStrings = Vec_PtrAlloc( 100 );
        Vec_IntForEachEntry( vLevel, iPo, k )
        {
            if ( ++Counter % 100 == 0 )
                printf( "%6d finished...\r", Counter );
            assert( pvPiPerms == NULL || Vec_PtrArray(*pvPiPerms)[iPo] == NULL );
            vStr = Gia_ManIsoFindString( p, iPo, 0, pvPiPerms ? (Vec_Int_t **)Vec_PtrArray(*pvPiPerms) + iPo : NULL );
 
//            printf( "Output %2d : ", iPo );
//            Vec_IntPrint( Vec_PtrArray(*pvPiPerms)[iPo] );
 
            // check if this string already exists
            Vec_PtrForEachEntry( Vec_Str_t *, vStrings, vStr2, s )
                if ( Vec_StrCompareVec(vStr, vStr2) == 0 )
                    break;
            if ( s == Vec_PtrSize(vStrings) )
            {
                Vec_PtrPush( vStrings, vStr );
                Vec_PtrPush( vEquivs2, Vec_IntAlloc(8) );
            }
            else
                Vec_StrFree( vStr );
            // add this entry to the corresponding level
            vLevel2 = (Vec_Int_t *)Vec_PtrEntry( vEquivs2, sStart + s );
            Vec_IntPush( vLevel2, iPo );
        }
//        if ( Vec_PtrSize(vEquivs2) - sStart > 1 )
//            printf( "Refined class %d into %d classes.\n", i, Vec_PtrSize(vEquivs2) - sStart );
        Vec_VecFree( (Vec_Vec_t *)vStrings );
    }
    assert( Counter == Gia_ManPoNum(p) );
    Vec_VecSortByFirstInt( (Vec_Vec_t *)vEquivs2, 0 );
    Vec_VecFree( (Vec_Vec_t *)vEquivs );
    vEquivs = vEquivs2;
 
    // collect the first ones
    vRemain = Vec_IntAlloc( 100 );
    Vec_PtrForEachEntry( Vec_Int_t *, vEquivs, vLevel, i )
        Vec_IntPush( vRemain, Vec_IntEntry(vLevel, 0) );
 
    if ( fDualOut )
    {
        Vec_Int_t * vTemp = Vec_IntAlloc( Vec_IntSize(vRemain) );
        int i, Entry;
        Vec_IntForEachEntry( vRemain, Entry, i )
        {
//            printf( "%d ", Entry );
            Vec_IntPush( vTemp, 2*Entry );
            Vec_IntPush( vTemp, 2*Entry+1 );
        }
//        printf( "\n" );
        Vec_IntFree( vRemain );
        vRemain = vTemp;
        Gia_ManStop( p );
        p = pInit;
    }
 
 
    // derive the resulting AIG
    pPart = Gia_ManDupCones( p, Vec_IntArray(vRemain), Vec_IntSize(vRemain), 0 );
    Vec_IntFree( vRemain );
    // report the results
    nClasses = Vec_IntCountNonTrivial( vEquivs, &nUsedPos );
    if ( !fDualOut )
        printf( "Reduced %d outputs to %d equivalence classes (%d outputs are in %d non-trivial classes).  ", 
            Gia_ManPoNum(p), Vec_PtrSize(vEquivs), nUsedPos, nClasses );
    else
        printf( "Reduced %d dual outputs to %d dual outputs.  ", Gia_ManPoNum(p)/2, Gia_ManPoNum(pPart)/2 );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    if ( fVerbose )
    {
        printf( "Nontrivial classes:\n" );
        Vec_VecPrintInt( (Vec_Vec_t *)vEquivs, 1 );
    }
    if ( pvPosEquivs )
        *pvPosEquivs = vEquivs;
    else
        Vec_VecFree( (Vec_Vec_t *)vEquivs );
//    Gia_ManStopP( &pPart );
    return pPart;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManIsoReduce2()

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

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 718 of file giaIso2.c.

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

Here is the call graph for this function:

◆ Gia_ManIsSeqWithBoxes()

int Gia_ManIsSeqWithBoxes ( Gia_Man_t * p )

extern

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

Synopsis [Returns one if this is a seq AIG with non-trivial boxes.]

Description []

SideEffects []

SeeAlso []

Definition at line 98 of file giaTim.c.

{
    return (Gia_ManRegNum(p) > 0 && Gia_ManBoxNum(p) > 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManLevelize()

Vec_Vec_t * Gia_ManLevelize ( Gia_Man_t * p )

extern

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

Synopsis [Levelizes the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 403 of file giaDfs.c.

{ 
    Gia_Obj_t * pObj;
    Vec_Vec_t * vLevels;
    int nLevels, Level, i;
    nLevels = Gia_ManLevelNum( p );
    vLevels = Vec_VecStart( nLevels + 1 );
    Gia_ManForEachAnd( p, pObj, i )
    {
        Level = Gia_ObjLevel( p, pObj );
        assert( Level <= nLevels );
        Vec_VecPush( vLevels, Level, pObj );
    }
    return vLevels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManLevelizeR()

Vec_Wec_t * Gia_ManLevelizeR ( Gia_Man_t * p )

extern

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

Synopsis [Levelizes the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 430 of file giaDfs.c.

{ 
    Gia_Obj_t * pObj;
    Vec_Wec_t * vLevels;
    int nLevels, Level, i;
    nLevels = Gia_ManLevelRNum( p );
    vLevels = Vec_WecStart( nLevels + 1 );
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( i == 0 || (!Gia_ObjIsCo(pObj) && !Gia_ObjLevel(p, pObj)) )
            continue;
        Level = Gia_ObjLevel( p, pObj );
        assert( Level <= nLevels );
        Vec_WecPush( vLevels, Level, i );
    }
    return vLevels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManLevelNum()

int Gia_ManLevelNum ( Gia_Man_t * p )

extern

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 )

extern

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_ManLevelWithBoxes()

int Gia_ManLevelWithBoxes ( Gia_Man_t * p )

extern

Definition at line 478 of file giaTim.c.

{
    int nAnd2Delay = p->nAnd2Delay ? p->nAnd2Delay : 1;
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    Gia_Obj_t * pObj, * pObjIn;
    int i, k, j, curCi, curCo, LevelMax;
    assert( Gia_ManRegNum(p) == 0 );
    assert( Gia_ManBufNum(p) == 0 );
    // copy const and real PIs
    Gia_ManCleanLevels( p, Gia_ManObjNum(p) );
    Gia_ObjSetLevel( p, Gia_ManConst0(p), 0 );
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
    {
        pObj = Gia_ManCi( p, i );
        Gia_ObjSetLevel( p, pObj, Tim_ManGetCiArrival(pManTime, i) / nAnd2Delay );
        Gia_ObjSetTravIdCurrent( p, pObj );
    }
    // create logic for each box
    curCi = Tim_ManPiNum(pManTime);
    curCo = 0;
    for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
    {
        int nBoxInputs  = Tim_ManBoxInputNum( pManTime, i );
        int nBoxOutputs = Tim_ManBoxOutputNum( pManTime, i );
        float * pDelayTable = Tim_ManBoxDelayTable( pManTime, i );
        // compute level for TFI of box inputs
        for ( k = 0; k < nBoxInputs; k++ )
        {
            pObj = Gia_ManCo( p, curCo + k );
            if ( Gia_ManLevelWithBoxes_rec( p, Gia_ObjFanin0(pObj) ) )
            {
                printf( "Boxes are not in a topological order. Switching to level computation without boxes.\n" );
                return Gia_ManLevelNum( p );
            }
            // set box input level
            Gia_ObjSetCoLevel( p, pObj );
        }
        // compute level for box outputs
        for ( k = 0; k < nBoxOutputs; k++ )
        {
            pObj = Gia_ManCi( p, curCi + k );
            Gia_ObjSetTravIdCurrent( p, pObj );
            // evaluate delay of this output
            LevelMax = 0;
            assert( nBoxInputs == (int)pDelayTable[1] );
            for ( j = 0; j < nBoxInputs && (pObjIn = Gia_ManCo(p, curCo + j)); j++ )
                if ( (int)pDelayTable[3+k*nBoxInputs+j] != -ABC_INFINITY )
                    LevelMax = Abc_MaxInt( LevelMax, Gia_ObjLevel(p, pObjIn) + ((int)pDelayTable[3+k*nBoxInputs+j] / nAnd2Delay) );
            // set box output level
            Gia_ObjSetLevel( p, pObj, LevelMax );
        }
        curCo += nBoxInputs;
        curCi += nBoxOutputs;
    }
    // add remaining nodes
    p->nLevels = 0;
    for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
    {
        pObj = Gia_ManCo( p, i );
        Gia_ManLevelWithBoxes_rec( p, Gia_ObjFanin0(pObj) );
        Gia_ObjSetCoLevel( p, pObj );
        p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
    }
    curCo += Tim_ManPoNum(pManTime);
    // verify counts
    assert( curCi == Gia_ManCiNum(p) );
    assert( curCo == Gia_ManCoNum(p) );
//    printf( "Max level is %d.\n", p->nLevels );
    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 )

extern

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_ManLutFaninCount()

int Gia_ManLutFaninCount ( Gia_Man_t * p )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 108 of file giaIf.c.

{
    int i, Counter = 0;
    Gia_ManForEachLut( p, i )
        Counter += Gia_ObjLutSize(p, i);
    return Counter;
}

Here is the caller graph for this function:

◆ Gia_ManLutLevel()

int Gia_ManLutLevel	(	Gia_Man_t *	p,
		int **	ppLevels )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 165 of file giaIf.c.

{
    Gia_Obj_t * pObj;
    int i, k, iFan, Level;
    int * pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachLut( p, i )
    {
        Level = 0;
        Gia_LutForEachFanin( p, i, iFan, k )
            if ( Level < pLevels[iFan] )
                Level = pLevels[iFan];
        pLevels[i] = Level + 1;
    }
    Level = 0;
    Gia_ManForEachCo( p, pObj, k )
    {
        int LevelFan = pLevels[Gia_ObjFaninId0p(p, pObj)];
        Level = Abc_MaxInt( Level, LevelFan );
        pLevels[Gia_ObjId(p, pObj)] = LevelFan;
    }
    if ( ppLevels )
        *ppLevels = pLevels;
    else
        ABC_FREE( pLevels );
    return Level;
}

Here is the caller graph for this function:

◆ Gia_ManLutLevelWithBoxes()

int Gia_ManLutLevelWithBoxes ( Gia_Man_t * p )

extern

Definition at line 581 of file giaTim.c.

{
//    int nAnd2Delay = p->nAnd2Delay ? p->nAnd2Delay : 1;
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    Gia_Obj_t * pObj, * pObjIn;
    int i, k, j, curCi, curCo, LevelMax;
    assert( Gia_ManRegNum(p) == 0 );
    if ( pManTime == NULL )
        return Gia_ManLutLevel(p, NULL);
    // copy const and real PIs
    Gia_ManCleanLevels( p, Gia_ManObjNum(p) );
    Gia_ObjSetLevel( p, Gia_ManConst0(p), 0 );
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
    {
        pObj = Gia_ManCi( p, i );
//        Gia_ObjSetLevel( p, pObj, Tim_ManGetCiArrival(pManTime, i) / nAnd2Delay );
        Gia_ObjSetLevel( p, pObj, 0 );
        Gia_ObjSetTravIdCurrent( p, pObj );
    }
    // create logic for each box
    curCi = Tim_ManPiNum(pManTime);
    curCo = 0;
    for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
    {
        int nBoxInputs  = Tim_ManBoxInputNum( pManTime, i );
        int nBoxOutputs = Tim_ManBoxOutputNum( pManTime, i );
        float * pDelayTable = Tim_ManBoxDelayTable( pManTime, i );
        // compute level for TFI of box inputs
        for ( k = 0; k < nBoxInputs; k++ )
        {
            pObj = Gia_ManCo( p, curCo + k );
            if ( Gia_ManLutLevelWithBoxes_rec( p, Gia_ObjFanin0(pObj) ) )
            {
                printf( "Boxes are not in a topological order. Switching to level computation without boxes.\n" );
                return Gia_ManLevelNum( p );
            }
            // set box input level
            Gia_ObjSetCoLevel( p, pObj );
        }
        // compute level for box outputs
        for ( k = 0; k < nBoxOutputs; k++ )
        {
            pObj = Gia_ManCi( p, curCi + k );
            Gia_ObjSetTravIdCurrent( p, pObj );
            // evaluate delay of this output
            LevelMax = 0;
            assert( nBoxInputs == (int)pDelayTable[1] );
            for ( j = 0; j < nBoxInputs && (pObjIn = Gia_ManCo(p, curCo + j)); j++ )
                if ( (int)pDelayTable[3+k*nBoxInputs+j] != -ABC_INFINITY )
//                    LevelMax = Abc_MaxInt( LevelMax, Gia_ObjLevel(p, pObjIn) + ((int)pDelayTable[3+k*nBoxInputs+j] / nAnd2Delay) );
                    LevelMax = Abc_MaxInt( LevelMax, Gia_ObjLevel(p, pObjIn) + 1 );
            // set box output level
            Gia_ObjSetLevel( p, pObj, LevelMax );
        }
        curCo += nBoxInputs;
        curCi += nBoxOutputs;
    }
    // add remaining nodes
    p->nLevels = 0;
    for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
    {
        pObj = Gia_ManCo( p, i );
        Gia_ManLutLevelWithBoxes_rec( p, Gia_ObjFanin0(pObj) );
        Gia_ObjSetCoLevel( p, pObj );
        p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
    }
    curCo += Tim_ManPoNum(pManTime);
    // verify counts
    assert( curCi == Gia_ManCiNum(p) );
    assert( curCo == Gia_ManCoNum(p) );
//    printf( "Max level is %d.\n", p->nLevels );
    return p->nLevels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManLutNum()

int Gia_ManLutNum ( Gia_Man_t * p )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 146 of file giaIf.c.

{
    int i, Counter = 0;
    Gia_ManForEachLut( p, i )
        Counter ++;
    return Counter;
}

Here is the caller graph for this function:

◆ Gia_ManLutParams()

void Gia_ManLutParams	(	Gia_Man_t *	p,
		int *	pnCurLuts,
		int *	pnCurEdges,
		int *	pnCurLevels )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file giaIf.c.

{
    int fDisable2Lut = 1;
    if ( p->pManTime && Tim_ManBoxNum((Tim_Man_t *)p->pManTime) )
    {
        int i;
        *pnCurLuts = 0;
        *pnCurEdges = 0;
        Gia_ManForEachLut( p, i )
        {
            (*pnCurLuts)++;
            (*pnCurEdges) += Gia_ObjLutSize(p, i);
        }
        *pnCurLevels = Gia_ManLutLevelWithBoxes( p );
    }
    else
    {
        Gia_Obj_t * pObj;
        int i, k, iFan;
        int * pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) );
        *pnCurLuts = 0;
        *pnCurEdges = 0;
        *pnCurLevels = 0;
        Gia_ManForEachLut( p, i )
        {
            if ( Gia_ObjLutIsMux(p, i) && !(fDisable2Lut && Gia_ObjLutSize(p, i) == 2) )
            {
                int pFanins[3];
                if ( Gia_ObjLutSize(p, i) == 3 )
                {
                    Gia_ManPrintGetMuxFanins( p, Gia_ManObj(p, i), pFanins );
                    pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[pFanins[0]]+1 );
                    pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[pFanins[1]] );
                    pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[pFanins[2]] );
                }
                else if ( Gia_ObjLutSize(p, i) == 2 )
                {
                    pObj = Gia_ManObj( p, i );
                    pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[Gia_ObjFaninId0(pObj, i)] );
                    pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[Gia_ObjFaninId1(pObj, i)] );
                }
                *pnCurLevels = Abc_MaxInt( *pnCurLevels, pLevels[i] );
                (*pnCurEdges)++;
                //nMuxF++;
                continue;
            }
            (*pnCurLuts)++;
            (*pnCurEdges) += Gia_ObjLutSize(p, i);
            Gia_LutForEachFanin( p, i, iFan, k )
                pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[iFan] );
            pLevels[i]++;
            *pnCurLevels = Abc_MaxInt( *pnCurLevels, pLevels[i] );
        }
        ABC_FREE( pLevels );
    }
}

Here is the call graph for this function:

◆ Gia_ManLutSizeMax()

int Gia_ManLutSizeMax ( Gia_Man_t * p )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 127 of file giaIf.c.

{
    int i, nSizeMax = -1;
    Gia_ManForEachLut( p, i )
        nSizeMax = Abc_MaxInt( nSizeMax, Gia_ObjLutSize(p, i) );
    return nSizeMax;
}

Here is the caller graph for this function:

◆ Gia_ManMappingVerify()

void Gia_ManMappingVerify ( Gia_Man_t * p )

extern

Definition at line 2257 of file giaIf.c.

{
    Gia_Obj_t * pObj, * pFanin;
    int i, Result = 1;
    assert( Gia_ManHasMapping(p) );
    Gia_ManIncrementTravId( p );
    Gia_ManForEachBuf( p, pObj, i )
    {
        pFanin = Gia_ObjFanin0(pObj);
        if ( !Gia_ObjIsAndNotBuf(pFanin) )
            continue;
        if ( !Gia_ObjIsLut(p, Gia_ObjId(p, pFanin)) )
        {
            Abc_Print( -1, "Gia_ManMappingVerify: Buffer driver %d does not have mapping.\n", Gia_ObjId(p, pFanin) );
            Result = 0;
            continue;
        }
        Result &= Gia_ManMappingVerify_rec( p, pFanin );
    }
    Gia_ManForEachCo( p, pObj, i )
    {
        pFanin = Gia_ObjFanin0(pObj);
        if ( !Gia_ObjIsAndNotBuf(pFanin) )
            continue;
        if ( !Gia_ObjIsLut(p, Gia_ObjId(p, pFanin)) )
        {
            Abc_Print( -1, "Gia_ManMappingVerify: CO driver %d does not have mapping.\n", Gia_ObjId(p, pFanin) );
            Result = 0;
            continue;
        }
        Result &= Gia_ManMappingVerify_rec( p, pFanin );
    }
//    if ( Result && Gia_NtkIsRoot(p) )
//        Abc_Print( 1, "Mapping verified correctly.\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManMapShrink4()

Gia_Man_t * Gia_ManMapShrink4	(	Gia_Man_t *	p,
		int	fKeepLevel,
		int	fVerbose )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Performs AIG shrinking using the current mapping.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file giaShrink.c.

{
    Vec_Int_t * vLeaves, * vTruth, * vVisited, * vLeavesBest;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pFanin;
    unsigned * pTruth;
    int i, k, iFan;
    abctime clk = Abc_Clock();
//    int ClassCounts[222] = {0};
    int * pLutClass, Counter = 0;
    assert( Gia_ManHasMapping(p) );
    if ( Gia_ManLutSizeMax( p ) > 4 )
    {
        printf( "Resynthesis is not performed when nodes have more than 4 inputs.\n" );
        return NULL;
    }
    pLutClass   = ABC_CALLOC( int, Gia_ManObjNum(p) );
    vLeaves     = Vec_IntAlloc( 0 );
    vTruth      = Vec_IntAlloc( (1<<16) );
    vVisited    = Vec_IntAlloc( 0 );
    vLeavesBest = Vec_IntAlloc( 4 );
    // prepare the library
    Dar_LibPrepare( 5 ); 
    // clean the old manager
    Gia_ManCleanTruth( p );
    Gia_ManSetPhase( p );
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    // start the new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    Gia_ManCleanLevels( pNew, Gia_ManObjNum(p) );
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
        {
            pObj->Value = Gia_ManAppendCi( pNew );
            if ( p->vLevels )
                Gia_ObjSetLevel( pNew, Gia_ObjFromLit(pNew, Gia_ObjValue(pObj)), Gia_ObjLevel(p, pObj) );
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        }
        else if ( Gia_ObjIsLut(p, i) )
        {
            Counter++;
            // collect leaves of this gate
            Vec_IntClear( vLeaves );
            Gia_LutForEachFanin( p, i, iFan, k )
                Vec_IntPush( vLeaves, iFan );
            for ( ; k < 4; k++ )
                Vec_IntPush( vLeaves, 0 );
            //.compute the truth table 
            pTruth = Gia_ManConvertAigToTruth( p, pObj, vLeaves, vTruth, vVisited );
            // change from node IDs to their literals
            Gia_ManForEachObjVec( vLeaves, p, pFanin, k )
            {
//                assert( Gia_ObjValue(pFanin) != ~0 ); 
                Vec_IntWriteEntry( vLeaves, k, Gia_ObjValue(pFanin) != ~0 ? Gia_ObjValue(pFanin) : 0 );
            }
            // derive new structre
            if ( Gia_ManTruthIsConst0(pTruth, Vec_IntSize(vLeaves)) )
                pObj->Value = 0;
            else if ( Gia_ManTruthIsConst1(pTruth, Vec_IntSize(vLeaves)) )
                pObj->Value = 1;
            else
            {
                pObj->Value = Dar_LibEvalBuild( pNew, vLeaves, 0xffff & *pTruth, fKeepLevel, vLeavesBest );
                pObj->Value = Abc_LitNotCond( pObj->Value, Gia_ObjPhaseRealLit(pNew, pObj->Value) ^ pObj->fPhase );
            }
        }
    }
    // cleanup the AIG
    Gia_ManHashStop( pNew );
    // check the presence of dangling nodes
    if ( Gia_ManHasDangling(pNew) )
    {
        pNew = Gia_ManCleanup( pTemp = pNew );
        if ( fVerbose && Gia_ManAndNum(pNew) != Gia_ManAndNum(pTemp) )
            printf( "Gia_ManMapShrink4() node reduction after sweep %6d -> %6d.\n", Gia_ManAndNum(pTemp), Gia_ManAndNum(pNew) );
        Gia_ManStop( pTemp );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    Vec_IntFree( vLeaves );
    Vec_IntFree( vTruth );
    Vec_IntFree( vVisited );
    Vec_IntFree( vLeavesBest );
    if ( fVerbose )
    {
        printf( "Total gain in AIG nodes = %d.  ", Gia_ManObjNum(p)-Gia_ManObjNum(pNew) );
        ABC_PRT( "Total runtime", Abc_Clock() - clk );
    }
    ABC_FREE( pLutClass );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManMapShrink6()

Gia_Man_t * Gia_ManMapShrink6	(	Gia_Man_t *	p,
		int	nFanoutMax,
		int	fKeepLevel,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 401 of file giaShrink6.c.

{
    Shr_Man_t * pMan;
    Gia_Obj_t * pObj, * pFanin;
    word uTruth, uTruth0, uTruth1;
    int i, k, nDivs, iNode;
    int RetValue, Counter1 = 0, Counter2 = 0;
    abctime clk2, clk = Abc_Clock();
    abctime timeFanout = 0;
    assert( Gia_ManHasMapping(p) );
    pMan = Shr_ManAlloc( p );
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
        {
            pObj->Value = Gia_ManAppendCi( pMan->pNew );
            if ( p->vLevels )
                Gia_ObjSetLevel( pMan->pNew, Gia_ObjFromLit(pMan->pNew, Gia_ObjValue(pObj)), Gia_ObjLevel(p, pObj) );
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            pObj->Value = Gia_ManAppendCo( pMan->pNew, Gia_ObjFanin0Copy(pObj) );
        }
        else if ( Gia_ObjIsLut(p, i) )
        {
            // collect leaves of this gate  
            Vec_IntClear( pMan->vLeaves );
            Gia_LutForEachFanin( p, i, iNode, k )
                Vec_IntPush( pMan->vLeaves, iNode );
            assert( Vec_IntSize(pMan->vLeaves) <= 6 );
            // compute truth table 
            uTruth = Shr_ManComputeTruth6( pMan->pGia, pObj, pMan->vLeaves, pMan->vTruths );
            assert( pObj->Value == ~0 );
            if ( uTruth == 0 || ~uTruth == 0 )
                pObj->Value = Abc_LitNotCond( 0, ~uTruth == 0 );
            else
                Gia_ManForEachObjVec( pMan->vLeaves, p, pFanin, k )
                    if ( uTruth == Truth[k] || ~uTruth == Truth[k] )
                        pObj->Value = Abc_LitNotCond( pFanin->Value, ~uTruth == Truth[k] );
            if ( pObj->Value != ~0 )
                continue;
            // translate into new nodes
            Gia_ManForEachObjVec( pMan->vLeaves, p, pFanin, k )
            {
                if ( Abc_LitIsCompl(pFanin->Value) )
                    uTruth = ((uTruth & Truth[k]) >> (1 << k)) | ((uTruth & ~Truth[k]) << (1 << k));
                Vec_IntWriteEntry( pMan->vLeaves, k, Abc_Lit2Var(pFanin->Value) );
            }
            // compute divisors
            clk2 = Abc_Clock();
            nDivs = Shr_ManCollectDivisors( pMan, pMan->vLeaves, pMan->nDivMax, nFanoutMax );
            assert( nDivs <= pMan->nDivMax );
            timeFanout += Abc_Clock() - clk2;
            // compute truth tables
            Shr_ManComputeTruths( pMan->pNew, Vec_IntSize(pMan->vLeaves), pMan->vDivs, pMan->vDivTruths, pMan->vTruths );
            // perform resubstitution
            RetValue = Rsb_ManPerformResub6( pMan->pManRsb, Vec_IntSize(pMan->vLeaves), uTruth, pMan->vDivTruths, &uTruth0, &uTruth1, 0 );
            if ( RetValue ) // resub exists
            {
                Vec_Int_t * vResult = Rsb_ManGetFanins(pMan->pManRsb);
                Vec_IntClear( pMan->vDivResub );
                Vec_IntForEachEntry( vResult, iNode, k )
                    Vec_IntPush( pMan->vDivResub, Vec_IntEntry(pMan->vDivs, iNode) );
                pObj->Value = Shr_ObjPerformBidec( pMan, pMan->pManDec, pMan->pNew, pMan->vDivResub, uTruth1, uTruth0 | uTruth1 );
                Counter1++;
            }
            else
            {
                pObj->Value = Shr_ObjPerformBidec( pMan, pMan->pManDec, pMan->pNew, pMan->vLeaves, uTruth, ~(word)0 );
                Counter2++;
            }
        }
    }
    if ( fVerbose )
    {
        printf( "Performed %d resubs and %d decomps.  ", Counter1, Counter2 );
        printf( "Gain in AIG nodes = %d.  ", Gia_ManObjNum(p)-Gia_ManObjNum(pMan->pNew) );
        ABC_PRT( "Runtime", Abc_Clock() - clk );
//        ABC_PRT( "Divisors", timeFanout );        
    }
    return Shr_ManFree( pMan );
}

Here is the call graph for this function:

◆ Gia_ManMarkDangling()

int Gia_ManMarkDangling ( Gia_Man_t * p )

extern

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 )

extern

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_ManMemory()

double Gia_ManMemory ( Gia_Man_t * p )

extern

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

Synopsis [Returns memory used in megabytes.]

Description []

SideEffects []

SeeAlso []

Definition at line 194 of file giaMan.c.

{
    double Memory = sizeof(Gia_Man_t);
    Memory += sizeof(Gia_Obj_t) * Gia_ManObjNum(p);
    Memory += sizeof(int) * Gia_ManCiNum(p);
    Memory += sizeof(int) * Gia_ManCoNum(p);
    Memory += sizeof(int) * Vec_IntSize(&p->vHTable);
    Memory += sizeof(int) * Gia_ManObjNum(p) * (p->pRefs != NULL);
    Memory += Vec_IntMemory( p->vLevels );
    Memory += Vec_IntMemory( p->vCellMapping );
    Memory += Vec_IntMemory( &p->vCopies );
    Memory += Vec_FltMemory( p->vInArrs );
    Memory += Vec_FltMemory( p->vOutReqs );
    Memory += Vec_PtrMemory( p->vNamesIn );
    Memory += Vec_PtrMemory( p->vNamesOut );
    Memory += Vec_PtrMemory( p->vNamesNode );
    return Memory;
}

Here is the caller graph for this function:

◆ Gia_ManMiter()

Gia_Man_t * Gia_ManMiter	(	Gia_Man_t *	p0,
		Gia_Man_t *	p1,
		int	nInsDup,
		int	fDualOut,
		int	fSeq,
		int	fImplic,
		int	fVerbose )

extern

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

Synopsis [Creates miter of two designs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2983 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, iLit;
    if ( fSeq )
    {
        if ( Gia_ManPiNum(p0) != Gia_ManPiNum(p1) )
        {
            printf( "Gia_ManMiter(): Designs have different number of PIs.\n" );
            return NULL;
        }
        if ( Gia_ManPoNum(p0) != Gia_ManPoNum(p1) )
        {
            printf( "Gia_ManMiter(): Designs have different number of POs.\n" );
            return NULL;
        }
        if ( Gia_ManRegNum(p0) == 0 || Gia_ManRegNum(p1) == 0 )
        {
            printf( "Gia_ManMiter(): At least one of the designs has no registers.\n" );
            return NULL;
        }
    }
    else
    {
        if ( Gia_ManCiNum(p0) != Gia_ManCiNum(p1) )
        {
            printf( "Gia_ManMiter(): Designs have different number of CIs.\n" );
            return NULL;
        }
        if ( Gia_ManCoNum(p0) != Gia_ManCoNum(p1) )
        {
            printf( "Gia_ManMiter(): Designs have different number of COs.\n" );
            return NULL;
        }
    }
    // start the manager
    pNew = Gia_ManStart( Gia_ManObjNum(p0) + Gia_ManObjNum(p1) );
    pNew->pName = Abc_UtilStrsav( "miter" );
    // map combinational inputs
    Gia_ManFillValue( p0 );
    Gia_ManFillValue( p1 );
    Gia_ManConst0(p0)->Value = 0;
    Gia_ManConst0(p1)->Value = 0;
    // map internal nodes and outputs
    Gia_ManHashAlloc( pNew );
    if ( fSeq )
    {
        // create primary inputs
        Gia_ManForEachPi( p0, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
        Gia_ManForEachPi( p1, pObj, i )
            if ( i < Gia_ManPiNum(p1) - nInsDup )
                pObj->Value = Gia_ObjToLit( pNew, Gia_ManPi(pNew, i) );
            else
                pObj->Value = Gia_ManAppendCi( pNew );
        // create latch outputs
        Gia_ManForEachRo( p0, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
        Gia_ManForEachRo( p1, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
        // create primary outputs
        Gia_ManForEachPo( p0, pObj, i )
        {
            Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) );
            Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(Gia_ManPo(p1,i)) );
            if ( fDualOut )
            {
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p1,i)) );
            }
            else if ( fImplic )
            {
                iLit = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Abc_LitNot(Gia_ObjFanin0Copy(Gia_ManPo(p1,i))) );
                Gia_ManAppendCo( pNew, iLit );
            }
            else 
            {
                iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManPo(p1,i)) );
                Gia_ManAppendCo( pNew, iLit );
            }
        }
        // create register inputs
        Gia_ManForEachRi( p0, pObj, i )
        {
            Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) );
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        }
        Gia_ManForEachRi( p1, pObj, i )
        {
            Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(pObj) );
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        }
        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p0) + Gia_ManRegNum(p1) );
    }
    else
    {
        // create combinational inputs
        Gia_ManForEachCi( p0, pObj, i )
            pObj->Value = Gia_ManAppendCi( pNew );
        Gia_ManForEachCi( p1, pObj, i )
            if ( i < Gia_ManCiNum(p1) - nInsDup )
                pObj->Value = Gia_ObjToLit( pNew, Gia_ManCi(pNew, i) );
            else
                pObj->Value = Gia_ManAppendCi( pNew );
        // create combinational outputs
        Gia_ManForEachCo( p0, pObj, i )
        {
            Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) );
            Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(Gia_ManCo(p1,i)) );
            if ( fDualOut )
            {
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManCo(p1,i)) );
            }
            else if ( fImplic )
            {
                iLit = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Abc_LitNot(Gia_ObjFanin0Copy(Gia_ManPo(p1,i))) );
                Gia_ManAppendCo( pNew, iLit );
            }
            else
            {
                iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManCo(p1,i)) );
                Gia_ManAppendCo( pNew, iLit );
            }
        }
    }
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
 
    pNew = Gia_ManDupNormalize( pTemp = pNew, 0 );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManMiter2()

Gia_Man_t * Gia_ManMiter2	(	Gia_Man_t *	pStart,
		char *	pInit,
		int	fVerbose )

extern

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

Synopsis [Creates miter of two designs.]

Description []

SideEffects []

SeeAlso []

Definition at line 3651 of file giaDup.c.

{
    Vec_Int_t * vCiValues, * vCoValues0, * vCoValues1;
    Gia_Man_t * pNew, * pUndc, * pTemp;
    Gia_Obj_t * pObj;
    char * pInitNew;
    int i, k;
    // check PI values
    for ( i = 0; i < Gia_ManPiNum(pStart); i++ )
        assert( pInit[i] == 'x' || pInit[i] == 'X' );
    // normalize the manager
    pUndc = Gia_ManDupZeroUndc( pStart, pInit + Gia_ManPiNum(pStart), 0, 0, fVerbose );
    // create new init string
    pInitNew = ABC_ALLOC( char, Gia_ManPiNum(pUndc)+1 );
    for ( i = 0; i < Gia_ManPiNum(pStart); i++ )
        pInitNew[i] = pInit[i];
    for ( i = k = Gia_ManPiNum(pStart); i < Gia_ManCiNum(pStart); i++ )
        if ( pInit[i] == 'x' || pInit[i] == 'X' )
            pInitNew[k++] = pInit[i];
    pInitNew[k] = 0;
    assert( k == Gia_ManPiNum(pUndc) );
    // derive miter
    pNew = Gia_ManStart( Gia_ManObjNum(pUndc) );
    pNew->pName = Abc_UtilStrsav( pUndc->pName );
    pNew->pSpec = Abc_UtilStrsav( pUndc->pSpec );
    Gia_ManConst0(pUndc)->Value = 0;
    Gia_ManHashAlloc( pNew );
    // add PIs of the first side
    Gia_ManForEachPi( pUndc, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    // add PIs of the second side
    vCiValues = Vec_IntAlloc( Gia_ManPiNum(pUndc) );
    Gia_ManForEachPi( pUndc, pObj, i )
        if ( pInitNew[i] == 'x' )
            Vec_IntPush( vCiValues, Gia_Obj2Lit( pNew, Gia_ManPi(pNew, i) ) );
        else if ( pInitNew[i] == 'X' ) 
            Vec_IntPush( vCiValues, Gia_ManAppendCi( pNew ) );
        else assert( 0 );
    // build flops and internal nodes
    Gia_ManForEachRo( pUndc, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( pUndc, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // collect CO values
    vCoValues0 = Vec_IntAlloc( Gia_ManPoNum(pUndc) );
    Gia_ManForEachCo( pUndc, pObj, i )
        Vec_IntPush( vCoValues0, Gia_ObjFanin0Copy(pObj) );
    // build the other side
    Gia_ManForEachPi( pUndc, pObj, i )
        pObj->Value = Vec_IntEntry( vCiValues, i );
    Gia_ManForEachRo( pUndc, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( pUndc, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    // collect CO values
    vCoValues1 = Vec_IntAlloc( Gia_ManPoNum(pUndc) );
    Gia_ManForEachCo( pUndc, pObj, i )
        Vec_IntPush( vCoValues1, Gia_ObjFanin0Copy(pObj) );
    // create POs
    Gia_ManForEachPo( pUndc, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashXor( pNew, Vec_IntEntry(vCoValues0, i), Vec_IntEntry(vCoValues1, i) ) );
    // create flop inputs
    Gia_ManForEachRi( pUndc, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Vec_IntEntry(vCoValues0, Gia_ManPoNum(pUndc)+i) );
    Gia_ManForEachRi( pUndc, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Vec_IntEntry(vCoValues1, Gia_ManPoNum(pUndc)+i) );
    Vec_IntFree( vCoValues0 );
    Vec_IntFree( vCoValues1 );
    Vec_IntFree( vCiValues );
    ABC_FREE( pInitNew );
    // cleanup
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, 2*Gia_ManRegNum(pUndc) );
    Gia_ManStop( pUndc );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManMiterInverse()

Gia_Man_t * Gia_ManMiterInverse	(	Gia_Man_t *	pBot,
		Gia_Man_t *	pTop,
		int	fDualOut,
		int	fVerbose )

extern

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

Synopsis [Creates miter of two designs.]

Description []

SideEffects []

SeeAlso []

Definition at line 3130 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, iLit;
    int nInputs1 = Gia_ManCiNum(pTop) - Gia_ManCoNum(pBot);
    int nInputs2 = Gia_ManCiNum(pBot) - Gia_ManCoNum(pTop);
    if ( nInputs1 == nInputs2 )
        printf( "Assuming that the circuits have %d shared inputs, ordered first.\n", nInputs1 );
    else
    {
        printf( "The number of inputs and outputs does not match.\n" );
        return NULL;
    }
    pNew = Gia_ManStart( Gia_ManObjNum(pBot) + Gia_ManObjNum(pTop) );
    pNew->pName = Abc_UtilStrsav( "miter" );
    Gia_ManFillValue( pBot );
    Gia_ManFillValue( pTop );
    Gia_ManConst0(pBot)->Value = 0;
    Gia_ManConst0(pTop)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCi( pBot, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
//    Gia_ManForEachCo( pBot, pObj, i )
//        Gia_ManMiter_rec( pNew, pBot, Gia_ObjFanin0(pObj) );
    Gia_ManForEachAnd( pBot, pObj, i )
    {
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    }
    Gia_ManForEachCo( pBot, pObj, i )
        pObj->Value = Gia_ObjFanin0Copy(pObj);
    Gia_ManForEachCi( pTop, pObj, i )
        if ( i < nInputs1 )
            pObj->Value = Gia_ManCi(pBot, i)->Value;
        else
            pObj->Value = Gia_ManCo(pBot, i-nInputs1)->Value;
//    Gia_ManForEachCo( pTop, pObj, i )
//        Gia_ManMiter_rec( pNew, pTop, Gia_ObjFanin0(pObj) );
    Gia_ManForEachAnd( pTop, pObj, i )
    {
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    }
    Gia_ManForEachCo( pTop, pObj, i )
    {
        if ( fDualOut )
        {
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
            Gia_ManAppendCo( pNew, Gia_ManCi(pBot, i+nInputs1)->Value );
        }
        else
        {
            iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ManCi(pBot, i+nInputs1)->Value );
            Gia_ManAppendCo( pNew, iLit );
        }
    }
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    assert( (pBot->vBarBufs == NULL) == (pTop->vBarBufs == NULL) );
    if ( pBot->vBarBufs )
    {
        pNew->vBarBufs = Vec_IntAlloc( 1000 );
        Vec_IntAppend( pNew->vBarBufs, pBot->vBarBufs );
        Vec_IntAppend( pNew->vBarBufs, pTop->vBarBufs );
        //printf( "Miter has %d buffers (%d groups).\n", pNew->nBufs, Vec_IntSize(pNew->vBarBufs) );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManNonRegBoxNum()

int Gia_ManNonRegBoxNum ( Gia_Man_t * p )

extern

Definition at line 58 of file giaTim.c.

{
    return Gia_ManBoxNum(p) - Gia_ManRegBoxNum(p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManOrderReverse()

Vec_Int_t * Gia_ManOrderReverse ( Gia_Man_t * p )

extern

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

Synopsis [Computes reverse topological order.]

Description [Assumes that levels are already assigned. The levels of CO nodes may not be assigned.]

SideEffects []

SeeAlso []

Definition at line 459 of file giaDfs.c.

{
    Gia_Obj_t * pObj;
    Vec_Vec_t * vLevels;
    Vec_Ptr_t * vLevel;
    Vec_Int_t * vResult;
    int i, k;
    vLevels = Vec_VecStart( 100 );
    // make sure levels are assigned
    Gia_ManForEachAnd( p, pObj, i )
        assert( Gia_ObjLevel(p, pObj) > 0 );
    // add CO nodes based on the level of their fanin
    Gia_ManForEachCo( p, pObj, i )
        Vec_VecPush( vLevels, Gia_ObjLevel(p, Gia_ObjFanin0(pObj)), pObj );
    // add other nodes based on their level
    Gia_ManForEachObj( p, pObj, i )
        if ( !Gia_ObjIsCo(pObj) )
            Vec_VecPush( vLevels, Gia_ObjLevel(p, pObj), pObj );
    // put the nodes in the reverse topological order
    vResult = Vec_IntAlloc( Gia_ManObjNum(p) );
    Vec_VecForEachLevelReverse( vLevels, vLevel, i )
        Vec_PtrForEachEntry( Gia_Obj_t *, vLevel, pObj, k )
            Vec_IntPush( vResult, Gia_ObjId(p, pObj) );
    Vec_VecFree( vLevels );
    return vResult;
}

Here is the caller graph for this function:

◆ Gia_ManOrderWithBoxes()

Vec_Int_t * Gia_ManOrderWithBoxes ( Gia_Man_t * p )

extern

Definition at line 286 of file giaTim.c.

{
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    Vec_Int_t * vNodes;
    Gia_Obj_t * pObj;
    int i, k, curCi, curCo;
    assert( pManTime != NULL );
    assert( Gia_ManIsNormalized( p ) );
    // start trav IDs
    Gia_ManIncrementTravId( p );
    // start the array
    vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
    // include constant
    Vec_IntPush( vNodes, 0 );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    // include primary inputs
    for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
    {
        pObj = Gia_ManCi( p, i );
        Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
        Gia_ObjSetTravIdCurrent( p, pObj );
        assert( Gia_ObjId(p, pObj) == i+1 );
    }
    // for each box, include box nodes
    curCi = Tim_ManPiNum(pManTime);
    curCo = 0;
    for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
    {
        // add internal nodes
        for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
        {
            pObj = Gia_ManCo( p, curCo + k );
            if ( Gia_ManOrderWithBoxes_rec( p, Gia_ObjFanin0(pObj), vNodes ) )
            {
                int iCiNum  = p->iData2;
                int iBoxNum = Tim_ManBoxFindFromCiNum( pManTime, iCiNum );
                printf( "The command has to terminate. Boxes are not in a topological order.\n" );
                printf( "The following information may help debugging (numbers are 0-based):\n" );
                printf( "Input %d of BoxA %d (1stCI = %d; 1stCO = %d) has TFI with CI %d,\n", 
                    k, i, Tim_ManBoxOutputFirst(pManTime, i), Tim_ManBoxInputFirst(pManTime, i), iCiNum );
                printf( "which corresponds to output %d of BoxB %d (1stCI = %d; 1stCO = %d).\n", 
                    iCiNum - Tim_ManBoxOutputFirst(pManTime, iBoxNum), iBoxNum, 
                    Tim_ManBoxOutputFirst(pManTime, iBoxNum), Tim_ManBoxInputFirst(pManTime, iBoxNum) );
                printf( "In a correct topological order, BoxB should precede BoxA.\n" );
                Vec_IntFree( vNodes );
                p->iData2 = 0;
                return NULL;
            }
        }
        // add POs corresponding to box inputs
        for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
        {
            pObj = Gia_ManCo( p, curCo + k );
            Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
        }
        curCo += Tim_ManBoxInputNum(pManTime, i);
        // add PIs corresponding to box outputs
        for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
        {
            pObj = Gia_ManCi( p, curCi + k );
            Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
            Gia_ObjSetTravIdCurrent( p, pObj );
        }
        curCi += Tim_ManBoxOutputNum(pManTime, i);
    }
    // add remaining nodes
    for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
    {
        pObj = Gia_ManCo( p, i );
        Gia_ManOrderWithBoxes_rec( p, Gia_ObjFanin0(pObj), vNodes );
    }
    // add POs
    for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
    {
        pObj = Gia_ManCo( p, i );
        Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
    }
    curCo += Tim_ManPoNum(pManTime);
    // verify counts
    assert( curCi == Gia_ManCiNum(p) );
    assert( curCo == Gia_ManCoNum(p) );
    //assert( Vec_IntSize(vNodes) == Gia_ManObjNum(p) );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManOrigIdsInit()

void Gia_ManOrigIdsInit ( Gia_Man_t * p )

extern

DECLARATIONS ///.

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

FileName [giaEquiv.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Manipulation of equivalence classes.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Manipulating original IDs.]

Description []

SideEffects []

SeeAlso []

Definition at line 46 of file giaEquiv.c.

{
    Vec_IntFreeP( &p->vIdsOrig );
    p->vIdsOrig = Vec_IntStartNatural( Gia_ManObjNum(p) );
}

Here is the caller graph for this function:

◆ Gia_ManOrigIdsReduce()

Gia_Man_t * Gia_ManOrigIdsReduce	(	Gia_Man_t *	p,
		Vec_Int_t *	vPairs )

extern

Definition at line 106 of file giaEquiv.c.

{
    Gia_Man_t * pNew = NULL;
    Gia_Obj_t * pObj, * pRepr; int i;
    Vec_Int_t * vMap = Gia_ManOrigIdsRemapPairs( vPairs, Gia_ManObjNum(p) );
    Gia_ManSetPhase( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManFillValue(p);
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachAnd( p, pObj, i )
    {
        if ( Vec_IntEntry(vMap, i) == -1 )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else
        {
            pRepr = Gia_ManObj( p, Vec_IntEntry(vMap, i) );
            pObj->Value = Abc_LitNotCond( pRepr->Value, pRepr->fPhase ^ pObj->fPhase );
        }
    }
    Gia_ManHashStop( pNew );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Vec_IntFree( vMap );
    // compute equivalences
    assert( !p->pReprs && !p->pNexts );
    p->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p) );
    for ( i = 0; i < Gia_ManObjNum(p); i++ )
        Gia_ObjSetRepr( p, i, GIA_VOID );
    Gia_ManFillValue(pNew);
    Gia_ManForEachAnd( p, pObj, i )
    {
        int iRepr = Abc_Lit2Var(pObj->Value);
        if ( iRepr == 0 )
        {
            Gia_ObjSetRepr( p, i, 0 );
            continue;
        }
        pRepr = Gia_ManObj( pNew, iRepr );
        if ( !~pRepr->Value ) // first time
        {
            pRepr->Value = i;
            continue;
        }
        // add equivalence
        Gia_ObjSetRepr( p, i, pRepr->Value );
    }
    p->pNexts = Gia_ManDeriveNexts( p );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManOrigIdsRemap()

void Gia_ManOrigIdsRemap	(	Gia_Man_t *	p,
		Gia_Man_t *	pNew )

extern

Definition at line 56 of file giaEquiv.c.

{
    Gia_Obj_t * pObj; int i;
    if ( p->vIdsOrig == NULL )
        return;
    Gia_ManOrigIdsStart( pNew );
    Vec_IntWriteEntry( pNew->vIdsOrig, 0, 0 );
    Gia_ManForEachObj1( p, pObj, i )
        if ( ~pObj->Value && Abc_Lit2Var(pObj->Value) && Vec_IntEntry(p->vIdsOrig, i) != -1 && Vec_IntEntry(pNew->vIdsOrig, Abc_Lit2Var(pObj->Value)) == -1 )
            Vec_IntWriteEntry( pNew->vIdsOrig, Abc_Lit2Var(pObj->Value), Vec_IntEntry(p->vIdsOrig, i) );
    Gia_ManForEachObj( pNew, pObj, i )
        assert( Vec_IntEntry(pNew->vIdsOrig, i) >= 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManOrigIdsStart()

void Gia_ManOrigIdsStart ( Gia_Man_t * p )

extern

Definition at line 51 of file giaEquiv.c.

{
    Vec_IntFreeP( &p->vIdsOrig );
    p->vIdsOrig = Vec_IntStartFull( Gia_ManObjNum(p) );
}

Here is the caller graph for this function:

◆ Gia_ManPerformBidec()

Gia_Man_t * Gia_ManPerformBidec	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 233 of file giaBidec.c.

{
    Bdc_Man_t * pManDec;
    Bdc_Par_t Pars = {0}, * pPars = &Pars;
    Vec_Int_t * vLeaves, * vTruth, * vVisited;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;//, clk = Abc_Clock();
    pPars->nVarsMax = Gia_ManLutSizeMax( p );
    pPars->fVerbose = fVerbose;
    if ( pPars->nVarsMax < 2 )
    {
        printf( "Resynthesis is not performed when nodes have less than 2 inputs.\n" );
        return NULL;
    }
    if ( pPars->nVarsMax > 15 )
    {
        printf( "Resynthesis is not performed when nodes have more than 15 inputs.\n" );
        return NULL;
    }
    vLeaves  = Vec_IntAlloc( 0 );
    vTruth   = Vec_IntAlloc( (1<<16) );
    vVisited = Vec_IntAlloc( 0 );
    // clean the old manager
    Gia_ManCleanTruth( p );
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    // start the new manager
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
//    Gia_ManCleanLevels( pNew, Gia_ManObjNum(p) );
    pManDec = Bdc_ManAlloc( pPars );
    Gia_ManForEachObj1( p, pObj, i )
    {        
        if ( Gia_ObjIsCi(pObj) ) // transfer the CI level (is it needed?)
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        else if ( Gia_ObjIsLut(p, i) )
            pObj->Value = Gia_ObjPerformBidec( pManDec, pNew, p, pObj, vLeaves, vTruth, vVisited );
    }
    Bdc_ManFree( pManDec );
    // cleanup the AIG
    Gia_ManHashStop( pNew );
    // check the presence of dangling nodes
    if ( Gia_ManHasDangling(pNew) )
    {
        pNew = Gia_ManCleanup( pTemp = pNew );
        if ( Gia_ManAndNum(pNew) != Gia_ManAndNum(pTemp) )
            printf( "Gia_ManPerformBidec() node count before and after: %6d and %6d.\n", Gia_ManAndNum(pNew), Gia_ManAndNum(pTemp) );
        Gia_ManStop( pTemp );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    Vec_IntFree( vLeaves );
    Vec_IntFree( vTruth );
    Vec_IntFree( vVisited );
    if ( fVerbose )
    {
//        printf( "Total gain in AIG nodes = %d.  ", Gia_ManObjNum(p)-Gia_ManObjNum(pNew) );
//        ABC_PRT( "Total runtime", Abc_Clock() - clk );
    }
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManPerformDsdBalance()

Gia_Man_t * Gia_ManPerformDsdBalance	(	Gia_Man_t *	p,
		int	nLutSize,
		int	nCutNum,
		int	nRelaxRatio,
		int	fVerbose )

extern

Definition at line 2678 of file giaIf.c.

{
    Gia_Man_t * pNew;
    If_Man_t * pIfMan;
    If_Par_t Pars, * pPars = &Pars;
    If_ManSetDefaultPars( pPars );
    pPars->nCutsMax    = nCutNum;
    pPars->nRelaxRatio = nRelaxRatio;
    pPars->fVerbose    = fVerbose;
    pPars->nLutSize    = nLutSize;
    pPars->fDsdBalance = 1;
    pPars->fUseDsd     = 1;
    pPars->fCutMin     = 1;
    pPars->fTruth      = 1;
    pPars->fExpRed     = 0;
    if ( Abc_FrameReadManDsd2() == NULL )
        Abc_FrameSetManDsd2( If_DsdManAlloc(pPars->nLutSize, 0) );
    // perform mapping
    pIfMan = Gia_ManToIf( p, pPars );
    pIfMan->pIfDsdMan = (If_DsdMan_t *)Abc_FrameReadManDsd2();
    if ( pPars->fDsdBalance )
        If_DsdManAllocIsops( pIfMan->pIfDsdMan, pPars->nLutSize );
    If_ManPerformMapping( pIfMan );
    pNew = Gia_ManFromIfAig( pIfMan );
    If_ManStop( pIfMan );
    Gia_ManTransferTiming( pNew, p );
    // transfer name
    assert( pNew->pName == NULL );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPerformDsdBalanceWin()

Gia_Man_t * Gia_ManPerformDsdBalanceWin	(	Gia_Man_t *	p,
		int	LevelMax,
		int	nTimeWindow,
		int	nLutSize,
		int	nCutNum,
		int	nRelaxRatio,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 298 of file giaBalMap.c.

{
    Vec_Int_t * vOuts;
    Gia_Man_t * pNew, * pWin, * pWinNew;
    assert( !LevelMax != !nTimeWindow );
    vOuts = Gia_ManFindLatest( p, LevelMax, nTimeWindow );
    if ( fVerbose )
        printf( "Collected %d outputs to extract.\n", Vec_IntSize(vOuts) );
    if ( Vec_IntSize(vOuts) == 0 )
    {
        Vec_IntFree( vOuts );
        return Gia_ManDup( p );
    }
    pWin = Gia_ManExtractWin( p, vOuts, 0 );
    pWinNew = Gia_ManPerformDsdBalance( pWin, nLutSize, nCutNum, nRelaxRatio, fVerbose );
    Gia_ManStop( pWin );
    pNew = Gia_ManInsertWin( p, vOuts, pWinNew );
    Gia_ManStop( pWinNew );
    Vec_IntFree( vOuts );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManPerformFx()

Gia_Man_t * Gia_ManPerformFx	(	Gia_Man_t *	p,
		int	nNewNodesMax,
		int	LitCountMax,
		int	fReverse,
		int	fVerbose,
		int	fVeryVerbose )

extern

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

Synopsis [Performs classical fast_extract on logic functions.]

Description []

SideEffects [Sorts the fanins of each cut in the increasing order.]

SeeAlso []

Definition at line 465 of file giaFx.c.

{
    extern int Fx_FastExtract( Vec_Wec_t * vCubes, int ObjIdMax, int nNewNodesMax, int LitCountMax, int fCanonDivs, int fVerbose, int fVeryVerbose );
    Gia_Man_t * pNew = NULL;
    Vec_Wec_t * vCubes;
    Vec_Str_t * vCompl;
    if ( Gia_ManAndNum(p) == 0 )
    {
        pNew = Gia_ManDup(p);
        Gia_ManTransferTiming( pNew, p );
        return pNew;
    }
//    abctime clk;
    assert( Gia_ManHasMapping(p) );   
    // collect information
    vCubes = Gia_ManFxRetrieve( p, &vCompl, fReverse );
    // call the fast extract procedure
//    clk = Abc_Clock();
    Fx_FastExtract( vCubes, Vec_StrSize(vCompl), nNewNodesMax, LitCountMax, 0, fVerbose, fVeryVerbose );
//    Abc_PrintTime( 1, "Fx runtime", Abc_Clock() - clk );
    // insert information
    pNew = Gia_ManFxInsert( p, vCubes, vCompl );
    Gia_ManTransferTiming( pNew, p );
    // cleanup
    Vec_WecFree( vCubes );
    Vec_StrFree( vCompl );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPerformLfMapping()

Gia_Man_t * Gia_ManPerformLfMapping	(	Gia_Man_t *	p,
		Jf_Par_t *	pPars,
		int	fNormalized )

extern

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

Synopsis [Interface of LUT mapping package.]

Description []

SideEffects []

SeeAlso []

Definition at line 2292 of file giaLf.c.

{
    Gia_Man_t * pNew;
    assert( !pPars->fCutGroup || pPars->nLutSize == 9 || pPars->nLutSize == 11 || pPars->nLutSize == 13 );
    // reconstruct GIA according to the hierarchy manager
    assert( pPars->pTimesArr == NULL );
    assert( pPars->pTimesReq == NULL );
    if ( p->pManTime )
    {
        if ( fNormalized )
        {
            pNew = Gia_ManDupUnnormalize( p );
            if ( pNew == NULL )
                return NULL;
            Gia_ManTransferTiming( pNew, p );
            p = pNew;
            // set arrival and required times
            pPars->pTimesArr = Tim_ManGetArrTimes( (Tim_Man_t *)p->pManTime );
            pPars->pTimesReq = Tim_ManGetReqTimes( (Tim_Man_t *)p->pManTime );
        }
        else
            p = Gia_ManDup( p );
    }
    else 
        p = Gia_ManDup( p );
    // perform mapping
    pNew = Lf_ManPerformMappingInt( p, pPars );
    if ( pNew != p )
    {
        // transfer name
        ABC_FREE( pNew->pName );
        ABC_FREE( pNew->pSpec );
        pNew->pName = Abc_UtilStrsav( p->pName );
        pNew->pSpec = Abc_UtilStrsav( p->pSpec );
        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
        // return the original (unmodified by the mapper) timing manager
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p );
    }
    // normalize and transfer mapping
    pNew = Gia_ManDupNormalize( p = pNew, 0 );
    Gia_ManTransferMapping( pNew, p );
//    Gia_ManTransferPacking( pNew, p );
    Gia_ManTransferTiming( pNew, p );
    Gia_ManStop( p );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManPerformMapping()

Gia_Man_t * Gia_ManPerformMapping	(	Gia_Man_t *	p,
		void *	pIfPars )

extern

Definition at line 2598 of file giaIf.c.

{
    Gia_Man_t * pNew;
    if ( p->pManTime && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) && Gia_ManIsNormalized(p) )
    {
        pNew = Gia_ManDupUnnormalize( p );
        if ( pNew == NULL )
            return NULL;
        Gia_ManTransferTiming( pNew, p );
        p = pNew;
        // mapping
        pNew = Gia_ManPerformMappingInt( p, (If_Par_t *)pp );
        if ( pNew != p )
        {
            Gia_ManTransferTiming( pNew, p );
            Gia_ManStop( p );
        }
        // normalize
        pNew = Gia_ManDupNormalize( p = pNew, ((If_Par_t *)pp)->fHashMapping );
        Gia_ManTransferMapping( pNew, p );
        Gia_ManTransferPacking( pNew, p );
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p );
        assert( Gia_ManIsNormalized(pNew) );
    }
    else 
    {
        pNew = Gia_ManPerformMappingInt( p, (If_Par_t *)pp );
        Gia_ManTransferTiming( pNew, p );
        if ( ((If_Par_t *)pp)->fHashMapping )
        {
            pNew = Gia_ManDupHashMapping( p = pNew );
            Gia_ManTransferPacking( pNew, p );
            Gia_ManTransferTiming( pNew, p );
            Gia_ManStop( p );
        }
    }
    pNew->MappedDelay = (int)((If_Par_t *)pp)->FinalDelay;
    pNew->MappedArea  = (int)((If_Par_t *)pp)->FinalArea;
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPerformSopBalance()

Gia_Man_t * Gia_ManPerformSopBalance	(	Gia_Man_t *	p,
		int	nCutNum,
		int	nRelaxRatio,
		int	fVerbose )

extern

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

Synopsis [Interface of other mapping-based procedures.]

Description []

SideEffects []

SeeAlso []

Definition at line 2651 of file giaIf.c.

{
    Gia_Man_t * pNew;
    If_Man_t * pIfMan;
    If_Par_t Pars, * pPars = &Pars;
    If_ManSetDefaultPars( pPars );
    pPars->nCutsMax    = nCutNum;
    pPars->nRelaxRatio = nRelaxRatio;
    pPars->fVerbose    = fVerbose;
    pPars->nLutSize    = 6;
    pPars->fDelayOpt   = 1;
    pPars->fCutMin     = 1;
    pPars->fTruth      = 1;
    pPars->fExpRed     = 0;
    // perform mapping
    pIfMan = Gia_ManToIf( p, pPars );
    If_ManPerformMapping( pIfMan );
    pNew = Gia_ManFromIfAig( pIfMan );
    If_ManStop( pIfMan );
    Gia_ManTransferTiming( pNew, p );
    // transfer name
    assert( pNew->pName == NULL );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPerformSopBalanceWin()

Gia_Man_t * Gia_ManPerformSopBalanceWin	(	Gia_Man_t *	p,
		int	LevelMax,
		int	nTimeWindow,
		int	nCutNum,
		int	nRelaxRatio,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 265 of file giaBalMap.c.

{
    Vec_Int_t * vOuts;
    Gia_Man_t * pNew, * pWin, * pWinNew;
    assert( !LevelMax != !nTimeWindow );
    vOuts = Gia_ManFindLatest( p, LevelMax, nTimeWindow );
    if ( fVerbose )
        printf( "Collected %d outputs to extract.\n", Vec_IntSize(vOuts) );
    if ( Vec_IntSize(vOuts) == 0 )
    {
        Vec_IntFree( vOuts );
        return Gia_ManDup( p );
    }
    pWin = Gia_ManExtractWin( p, vOuts, 0 );
    pWinNew = Gia_ManPerformSopBalance( pWin, nCutNum, nRelaxRatio, fVerbose );
    Gia_ManStop( pWin );
    pNew = Gia_ManInsertWin( p, vOuts, pWinNew );
    Gia_ManStop( pWinNew );
    Vec_IntFree( vOuts );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManPermuteInputs()

Gia_Man_t * Gia_ManPermuteInputs	(	Gia_Man_t *	p,
		int	nPpis,
		int	nExtra )

extern

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

Synopsis [Permute inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2758 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    for ( i = 0; i < Gia_ManPiNum(p) - nPpis - nExtra; i++ ) // regular PIs
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
    for ( i = Gia_ManPiNum(p) - nExtra; i < Gia_ManPiNum(p); i++ ) // extra PIs due to DC values
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
    for ( i = Gia_ManPiNum(p) - nPpis - nExtra; i < Gia_ManPiNum(p) - nExtra; i++ ) // pseudo-PIs
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
    for ( i = Gia_ManPiNum(p); i < Gia_ManCiNum(p); i++ ) // flop outputs
        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachCo( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrint()

void Gia_ManPrint ( Gia_Man_t * p )

extern

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_ManPrintCo()

void Gia_ManPrintCo	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

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_ManPrintCone()

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

extern

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 )

extern

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 )

extern

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_ManPrintFanio()

void Gia_ManPrintFanio	(	Gia_Man_t *	pGia,
		int	nNodes )

extern

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

Synopsis [Returns sorted array of node handles with largest fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 746 of file giaCof.c.

{
    Cof_Man_t * p;
    abctime clk = Abc_Clock();
    p = Cof_ManCreateLogicSimple( pGia );
    p->nLevels = 1 + Gia_ManLevelNum( pGia );
    p->pLevels = ABC_CALLOC( int, p->nLevels );
    Cof_ManPrintFanio( p );
 
    if ( nNodes > 0 )
    {
    Cof_ManResetTravId( p );
    Gia_ManHashStart( pGia );
    Cof_ManPrintHighFanout( p, nNodes );
    Gia_ManHashStop( pGia );
ABC_PRMn( "Memory for logic network", 4*p->nObjData );
ABC_PRT( "Time", Abc_Clock() - clk );
    }
 
    Cof_ManStop( p );
}

Here is the call graph for this function:

◆ Gia_ManPrintLutStats()

void Gia_ManPrintLutStats ( Gia_Man_t * p )

extern

Definition at line 727 of file giaIf.c.

{
    int i, nSizeMax, pCounts[33] = {0};
    nSizeMax = Gia_ManLutSizeMax( p );
    if ( nSizeMax > 32 )
    {
        Abc_Print( 1, "The max LUT size (%d) is too large.\n", nSizeMax );
        return;
    }
    Gia_ManForEachLut( p, i )
        pCounts[ Gia_ObjLutSize(p, i) ]++;
    Gia_ManPrintNodeProfile( pCounts, nSizeMax );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintMappingStats()

void Gia_ManPrintMappingStats	(	Gia_Man_t *	p,
		char *	pDumpFile )

extern

Definition at line 532 of file giaIf.c.

{
    int fDisable2Lut = 1;
    Gia_Obj_t * pObj;
    int * pLevels;
    int i, k, iFan, nLutSize = 0, nLuts = 0, nFanins = 0, LevelMax = 0, Ave = 0, nMuxF = 0;
    if ( !Gia_ManHasMapping(p) )
        return;
    pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachLut( p, i )
    {
        if ( Gia_ObjLutIsMux(p, i) && !(fDisable2Lut && Gia_ObjLutSize(p, i) == 2) )
        {
            int pFanins[3];
            if ( Gia_ObjLutSize(p, i) == 3 )
            {
                Gia_ManPrintGetMuxFanins( p, Gia_ManObj(p, i), pFanins );
                pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[pFanins[0]]+1 );
                pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[pFanins[1]] );
                pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[pFanins[2]] );
            }
            else if ( Gia_ObjLutSize(p, i) == 2 )
            {
                pObj = Gia_ManObj( p, i );
                pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[Gia_ObjFaninId0(pObj, i)] );
                pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[Gia_ObjFaninId1(pObj, i)] );
            }
            LevelMax = Abc_MaxInt( LevelMax, pLevels[i] );
            nFanins++;
            nMuxF++;
            continue;
        }
        nLuts++;
        nFanins += Gia_ObjLutSize(p, i);
        nLutSize = Abc_MaxInt( nLutSize, Gia_ObjLutSize(p, i) );
        Gia_LutForEachFanin( p, i, iFan, k )
            pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[iFan] );
        pLevels[i]++;
        LevelMax = Abc_MaxInt( LevelMax, pLevels[i] );
    }
    Gia_ManForEachCo( p, pObj, i )
        Ave += pLevels[Gia_ObjFaninId0p(p, pObj)];
    ABC_FREE( pLevels );
 
#ifdef WIN32
    {
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    Abc_Print( 1, "Mapping (K=%d)  :  ", nLutSize );
    SetConsoleTextAttribute( hConsole, 14 ); // yellow
    Abc_Print( 1, "lut =%7d  ",  nLuts );
    if ( nMuxF )
    Abc_Print( 1, "muxF =%7d  ",  nMuxF );
    SetConsoleTextAttribute( hConsole, 10 ); // green
    Abc_Print( 1, "edge =%8d  ", nFanins );
    SetConsoleTextAttribute( hConsole, 12 ); // red
    Abc_Print( 1, "lev =%5d ",   LevelMax );
    Abc_Print( 1, "(%.2f)  ",    (float)Ave / Gia_ManCoNum(p) );
//    Abc_Print( 1, "over =%5.1f %%  ", 100.0 * Gia_ManComputeOverlap(p) / Gia_ManAndNum(p) );
    if ( p->pManTime && Tim_ManBoxNum((Tim_Man_t *)p->pManTime) )
        Abc_Print( 1, "levB =%5d  ", Gia_ManLutLevelWithBoxes(p) );
    SetConsoleTextAttribute( hConsole, 7 );  // normal
    Abc_Print( 1, "mem =%5.2f MB", 4.0*(Gia_ManObjNum(p) + 2*nLuts + nFanins)/(1<<20) );
    Abc_Print( 1, "\n" );
    }
#else
    Abc_Print( 1, "Mapping (K=%d)  :  ", nLutSize );
    Abc_Print( 1, "%slut =%7d%s  ",  "\033[1;33m", nLuts,    "\033[0m" );  // yellow
    Abc_Print( 1, "%sedge =%8d%s  ", "\033[1;32m", nFanins,  "\033[0m" );  // green
    Abc_Print( 1, "%slev =%5d%s ",   "\033[1;31m", LevelMax, "\033[0m" );  // red
    Abc_Print( 1, "%s(%.2f)%s  ",    "\033[1;31m", (float)Ave / Gia_ManCoNum(p), "\033[0m" );
//    Abc_Print( 1, "over =%5.1f %%  ", 100.0 * Gia_ManComputeOverlap(p) / Gia_ManAndNum(p) );
    if ( p->pManTime && Tim_ManBoxNum((Tim_Man_t *)p->pManTime) )
        Abc_Print( 1, "%slevB =%5d%s  ", "\033[1;31m", Gia_ManLutLevelWithBoxes(p), "\033[0m" );
    Abc_Print( 1, "mem =%5.2f MB", 4.0*(Gia_ManObjNum(p) + 2*nLuts + nFanins)/(1<<20) );
    Abc_Print( 1, "\n" );
#endif
 
    if ( nMuxF )
        Gia_ManCountDupLut( p );
 
    //return;
    if ( pDumpFile )
    {
        static char FileNameOld[1000] = {0};
        static abctime clk = 0;
        FILE * pTable = fopen( pDumpFile, "a+" );
        if ( strcmp( FileNameOld, p->pName ) )
        {
            sprintf( FileNameOld, "%s_out", p->pName );
            fprintf( pTable, "\n" );
            fprintf( pTable, "%s ", p->pName );
            fprintf( pTable, " " );
            //fprintf( pTable, "%d ", Gia_ManAndNum(p) );
            fprintf( pTable, "%d ", Gia_ManRegNum(p) );
            fprintf( pTable, "%d ", nLuts           );
            fprintf( pTable, "%d ", Gia_ManLutLevelWithBoxes(p) );
            //fprintf( pTable, "%d ", Gia_ManRegBoxNum(p) );
            //fprintf( pTable, "%d ", Gia_ManNonRegBoxNum(p) );
            //fprintf( pTable, "%.2f", 1.0*(Abc_Clock() - clk)/CLOCKS_PER_SEC );
            clk = Abc_Clock();
        }
        else
        {
            //printf( "This part of the code is currently not used.\n" );
            //assert( 0 );
            fprintf( pTable, " " );
            fprintf( pTable, " " );
            fprintf( pTable, "%d ", Gia_ManRegNum(p) );
            fprintf( pTable, "%d ", nLuts           );
            fprintf( pTable, "%d ", Gia_ManLutLevelWithBoxes(p) );
            //fprintf( pTable, "%d ", Gia_ManRegBoxNum(p) );
            //fprintf( pTable, "%d ", Gia_ManNonRegBoxNum(p) );
//            fprintf( pTable, "%.2f", 1.0*(Abc_Clock() - clk)/CLOCKS_PER_SEC );
            clk = Abc_Clock();
        }
        fclose( pTable );
    }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintMiterStatus()

void Gia_ManPrintMiterStatus ( Gia_Man_t * p )

extern

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 679 of file giaMan.c.

{
    Gia_Obj_t * pObj, * pChild;
    int i, nSat = 0, nUnsat = 0, nUndec = 0, iOut = -1;
    Gia_ManForEachPo( p, pObj, i )
    {
        pChild = Gia_ObjChild0(pObj);
        // check if the output is constant 0
        if ( pChild == Gia_ManConst0(p) )
            nUnsat++;
        // check if the output is constant 1
        else if ( pChild == Gia_ManConst1(p) )
        {
            nSat++;
            if ( iOut == -1 )
                iOut = i;
        }
        // check if the output is a primary input
        else if ( Gia_ObjIsPi(p, Gia_Regular(pChild)) )
        {
            nSat++;
            if ( iOut == -1 )
                iOut = i;
        }
/*
        // check if the output is 1 for the 0000 pattern
        else if ( Gia_Regular(pChild)->fPhase != (unsigned)Gia_IsComplement(pChild) )
        {
            nSat++;
            if ( iOut == -1 )
                iOut = i;
        }
*/
        else
            nUndec++;
    }
    Abc_Print( 1, "Outputs = %7d.  Unsat = %7d.  Sat = %7d.  Undec = %7d.\n",
        Gia_ManPoNum(p), nUnsat, nSat, nUndec );
}

◆ Gia_ManPrintMuxStats()

void Gia_ManPrintMuxStats ( Gia_Man_t * p )

extern

Definition at line 63 of file giaMuxes.c.

{
    int nAnds, nMuxes, nXors, nTotal;
    if ( p->pMuxes )
    {
        nAnds  = Gia_ManAndNotBufNum(p)-Gia_ManXorNum(p)-Gia_ManMuxNum(p);
        nXors  = Gia_ManXorNum(p);
        nMuxes = Gia_ManMuxNum(p);
        nTotal = nAnds + 3*nXors + 3*nMuxes;
    }
    else 
    {
        Gia_ManCountMuxXor( p, &nMuxes, &nXors );
        nAnds  = Gia_ManAndNotBufNum(p) - 3*nMuxes - 3*nXors;
        nTotal = Gia_ManAndNotBufNum(p);
    }
    Abc_Print( 1, "stats:  " );
    Abc_Print( 1, "xor =%8d %6.2f %%   ", nXors,  300.0*nXors/nTotal );
    Abc_Print( 1, "mux =%8d %6.2f %%   ", nMuxes, 300.0*nMuxes/nTotal );
    Abc_Print( 1, "and =%8d %6.2f %%   ", nAnds,  100.0*nAnds/nTotal );
    Abc_Print( 1, "obj =%8d  ", Gia_ManAndNotBufNum(p) );
    fflush( stdout );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintNpnClasses()

void Gia_ManPrintNpnClasses ( Gia_Man_t * p )

extern

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

Synopsis [Prints NPN class statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 804 of file giaMan.c.

{
    extern char ** Kit_DsdNpn4ClassNames();
    char ** pNames = Kit_DsdNpn4ClassNames();
    Vec_Int_t * vLeaves, * vTruth, * vVisited;
    int * pLutClass, ClassCounts[222] = {0};
    int i, k, iFan, Class, OtherClasses, OtherClasses2, nTotal, Counter, Counter2;
    unsigned * pTruth; int nLutSize = 0;
    assert( Gia_ManHasMapping(p) );
    //assert(  Gia_ManLutSizeMax( p ) <= 4 );
    vLeaves   = Vec_IntAlloc( 100 );
    vVisited  = Vec_IntAlloc( 100 );
    vTruth    = Vec_IntAlloc( (1<<16) );
    pLutClass = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManCleanTruth( p );
    Gia_ManForEachLut( p, i )
    {
        nLutSize = Abc_MaxInt( nLutSize, Gia_ObjLutSize(p,i) );
        if ( Gia_ObjLutSize(p,i) > 4 )
            continue;
        Vec_IntClear( vLeaves );
        Gia_LutForEachFanin( p, i, iFan, k )
            Vec_IntPush( vLeaves, iFan );
        for ( ; k < 4; k++ )
            Vec_IntPush( vLeaves, 0 );
        pTruth = Gia_ManConvertAigToTruth( p, Gia_ManObj(p, i), vLeaves, vTruth, vVisited );
        Class = Dar_LibReturnClass( *pTruth );
        ClassCounts[ Class ]++;
        pLutClass[i] = Class;
    }
    Vec_IntFree( vLeaves );
    Vec_IntFree( vTruth );
    Vec_IntFree( vVisited );
    Vec_IntFreeP( &p->vTruths );
    nTotal = 0;
    for ( i = 0; i < 222; i++ )
        nTotal += ClassCounts[i];
    Abc_Print( 1, "NPN CLASS STATISTICS (for %d LUT4 present in the current mapping):\n", nTotal );
    OtherClasses = 0;
    for ( i = k = 0; i < 222; i++ )
    {
        if ( ClassCounts[i] == 0 )
            continue;
//        if ( 100.0 * ClassCounts[i] / (nTotal+1) < 0.1 ) // do not show anything below 0.1 percent
//            continue;
        OtherClasses += ClassCounts[i];
        Abc_Print( 1, "%3d: Class %3d :  Count = %6d   (%7.2f %%)   %s\n", 
            ++k, i, ClassCounts[i], 100.0 * ClassCounts[i] / (nTotal+1), pNames[i] );
    }
    OtherClasses = nTotal - OtherClasses;
    Abc_Print( 1, "Other     :  Count = %6d   (%7.2f %%)\n", 
        OtherClasses, 100.0 * OtherClasses / (nTotal+1) );
    // count the number of LUTs that have MUX function and two fanins with MUX functions
    OtherClasses = OtherClasses2 = 0;
    ABC_FREE( p->pRefs );
    Gia_ManSetRefsMapped( p );
    Gia_ManForEachLut( p, i )
    {
        if ( pLutClass[i] != 109 )
            continue;
        Counter = Counter2 = 0;
        Gia_LutForEachFanin( p, i, iFan, k )
        {
            Counter  += (pLutClass[iFan] == 109);
            Counter2 += (pLutClass[iFan] == 109) && (Gia_ObjRefNumId(p, iFan) == 1);
        }
        OtherClasses  += (Counter > 1);
        OtherClasses2 += (Counter2 > 1);
//            Abc_Print( 1, "%d -- ", pLutClass[i] );
//            Gia_LutForEachFanin( p, i, iFan, k )
//                Abc_Print( 1, "%d ", pLutClass[iFan] );
//            Abc_Print( 1, "\n" );
    }
    ABC_FREE( p->pRefs );
    Abc_Print( 1, "Approximate number of 4:1 MUX structures: All = %6d  (%7.2f %%)  MFFC = %6d  (%7.2f %%)\n", 
        OtherClasses,  100.0 * OtherClasses  / (nTotal+1),
        OtherClasses2, 100.0 * OtherClasses2 / (nTotal+1) );
    // print information about LUT pairs
    if ( nLutSize <= 4 )
    {
        int nTopPairs = 100, nTopShow = 30;
        int i, j, k, iFan, * pVec = NULL;
        Vec_Int_t * vPairs = Vec_IntAlloc( 3 * nTopPairs );
        Gia_ManForEachLut( p, j ) {
            Gia_LutForEachFanin( p, j, iFan, k ) {
                int Num1 = pLutClass[iFan];
                int Num2 = pLutClass[j];
                assert( Vec_IntSize(vPairs) % 3 == 0 );
                for ( i = 0; i < Vec_IntSize(vPairs); i += 3 )
                    if ( Vec_IntEntry(vPairs, i+0) == Num1 && Vec_IntEntry(vPairs, i+1) == Num2 )
                        break;
                if ( i == Vec_IntSize(vPairs) ) {
                    if ( Vec_IntSize(vPairs) < 3*nTopPairs ) {
                        Vec_IntPush( vPairs, Num1 );
                        Vec_IntPush( vPairs, Num2 );
                        Vec_IntPush( vPairs, 1 );
                    }
                    continue;
                }
                // found this pair
                assert( Vec_IntEntry(vPairs, i+0) == Num1 );
                assert( Vec_IntEntry(vPairs, i+1) == Num2 );                
                Vec_IntAddToEntry( vPairs, i+2, 1 );
                // sort 
                pVec = Vec_IntArray( vPairs );
                while ( i > 0 && pVec[i+2] > pVec[i-1] ) {
                    ABC_SWAP( int, pVec[i+0], pVec[i-3] )
                    ABC_SWAP( int, pVec[i+1], pVec[i-2] )
                    ABC_SWAP( int, pVec[i+2], pVec[i-1] )
                    i -= 3;
                }
                while ( i < Vec_IntSize(vPairs) - 3 && pVec[i+2] < pVec[i+5] ) {
                    ABC_SWAP( int, pVec[i+0], pVec[i+3] )
                    ABC_SWAP( int, pVec[i+1], pVec[i+4] )
                    ABC_SWAP( int, pVec[i+2], pVec[i+5] )
                    i += 3;
                    assert( 0 );
                }                
            }
        }
        pVec = Vec_IntArray( vPairs );
        nTopShow = Abc_MinInt( nTopShow, Vec_IntSize(vPairs)/3 );
        for ( i = 0; i < 3*nTopShow; i += 3 )
            printf( "%3d : (%3d %3d) x %3d\n", i/3, pVec[i+0], pVec[i+1], pVec[i+2] );
        Vec_IntFree( vPairs );
    }    
    ABC_FREE( pLutClass );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintOutputLutStats()

void Gia_ManPrintOutputLutStats ( Gia_Man_t * p )

extern

Definition at line 497 of file giaIf.c.

{
    int Limit = 100000;
    int nLutSize = Gia_ManLutSizeMax(p);
    Vec_Int_t * vLuts = Vec_IntAlloc( 1000 );
    Vec_Int_t * vNodes = Vec_IntStart( Limit );
    Vec_Int_t * vLevels = Vec_IntStart( Limit );
    Vec_Int_t * vLevel = Vec_IntStart( Gia_ManObjNum(p) );
    int i, DriverId, Value, nTotalLuts = 0;
    Gia_ManForEachCoDriverId( p, DriverId, i ) {
        Vec_IntClear( vLuts );
        Gia_ManIncrementTravId(p);
        Gia_ManCollectLuts_rec( p, DriverId, vLuts );
        if ( Vec_IntSize(vLuts) < Limit )
            Vec_IntAddToEntry( vNodes, Vec_IntSize(vLuts), 1 );
        int Level = Gia_ManCountLutLevels( p, vLuts, vLevel );
        if ( Level < Limit )
            Vec_IntAddToEntry( vLevels, Level, 1 );
        nTotalLuts += Vec_IntSize(vLuts);
    }
    printf( "Level count statistics for %d AIG outputs:\n", Gia_ManCoNum(p) );
    Vec_IntForEachEntry( vLevels, Value, i )
        if ( Value )
            printf( "   %2d level : Function count = %8d (%6.2f %%)\n", i, Value, 100.0*Value/Gia_ManCoNum(p) );
    printf( "LUT count statistics for %d AIG outputs:\n", Gia_ManCoNum(p) );
    Vec_IntForEachEntry( vNodes, Value, i )
        if ( Value )
            printf( "   %2d LUT%d  : Function count = %8d (%6.2f %%)\n", i, nLutSize, Value, 100.0*Value/Gia_ManCoNum(p) );
    printf( "Sum total of LUT counts for all outputs = %d. Shared LUT count = %d.\n", nTotalLuts, Gia_ManLutNum(p) );
    Vec_IntFree( vLuts );
    Vec_IntFree( vNodes );
    Vec_IntFree( vLevels );
    Vec_IntFree( vLevel );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintOutputProb()

Vec_Flt_t * Gia_ManPrintOutputProb ( Gia_Man_t * p )

extern

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

Synopsis [Determine probability of being 1 at the outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 848 of file giaSwitch.c.

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintPackingStats()

void Gia_ManPrintPackingStats ( Gia_Man_t * p )

extern

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 663 of file giaIf.c.

{
    int fVerbose = 0;
    int nObjToShow = 200;
    int nNumStr[5] = {0};
    int i, k, Entry, nEntries, nEntries2, MaxSize = -1, Count = 0;
    if ( p->vPacking == NULL )
        return;
    nEntries = Vec_IntEntry( p->vPacking, 0 );
    nEntries2 = 0;
    Vec_IntForEachEntryStart( p->vPacking, Entry, i, 1 )
    {
        assert( Entry > 0 && Entry < 4 );
        nNumStr[Entry]++;
        i++;
        if ( fVerbose && nEntries2 < nObjToShow ) Abc_Print( 1, "{ " );
        for ( k = 0; k < Entry; k++, i++ )
            if ( fVerbose && nEntries2 < nObjToShow ) Abc_Print( 1, "%d ", Vec_IntEntry(p->vPacking, i) );
        if ( fVerbose && nEntries2 < nObjToShow ) Abc_Print( 1, "}\n" );
        i--;
        nEntries2++;
    }
    assert( nEntries == nEntries2 );
    if ( nNumStr[3] > 0 )
        MaxSize = 3;
    else if ( nNumStr[2] > 0 )
        MaxSize = 2;
    else if ( nNumStr[1] > 0 )
        MaxSize = 1;
    Abc_Print( 1, "Packing (N=%d)  :  ", MaxSize );
    for ( i = 1; i <= MaxSize; i++ )
    {
        Abc_Print( 1, "%d x LUT = %d   ", i, nNumStr[i] );
        Count += i * nNumStr[i];
    }
    Abc_Print( 1, "Total = %d   ", nEntries2 );
    Abc_Print( 1, "Total LUT = %d", Count );
    Abc_Print( 1, "\n" );
}

Here is the caller graph for this function:

◆ Gia_ManPrintStats()

void Gia_ManPrintStats	(	Gia_Man_t *	p,
		Gps_Par_t *	pPars )

extern

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 495 of file giaMan.c.

{
    extern float Gia_ManLevelAve( Gia_Man_t * p );
    int fHaveLevels = p->vLevels != NULL;
    if ( pPars && pPars->fMiter )
    {
        Gia_ManPrintStatsMiter( p, 0 );
        return;
    }
    if ( pPars && pPars->fNoColor )
    {
        if ( p->pName )
            Abc_Print( 1, "%-8s : ", p->pName );
    }
    else
    {
#ifdef WIN32
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 15 ); // bright
    if ( p->pName )
        Abc_Print( 1, "%-8s : ", p->pName );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
#else
    if ( p->pName )
        Abc_Print( 1, "%s%-8s%s : ", "\033[1;37m", p->pName, "\033[0m" );  // bright
#endif
    }
    Abc_Print( 1, "i/o =%7d/%7d", 
        Gia_ManPiNum(p) - Gia_ManBoxCiNum(p) - Gia_ManRegBoxNum(p), 
        Gia_ManPoNum(p) - Gia_ManBoxCoNum(p) - Gia_ManRegBoxNum(p) );
    if ( Gia_ManConstrNum(p) )
        Abc_Print( 1, "(c=%d)", Gia_ManConstrNum(p) );
    if ( Gia_ManRegNum(p) )
        Abc_Print( 1, "  ff =%7d", Gia_ManRegNum(p) );
    if ( Gia_ManRegBoxNum(p) )
        Abc_Print( 1, "  boxff =%d(%d)", Gia_ManRegBoxNum(p), Gia_ManClockDomainNum(p) );
    if ( pPars && pPars->fNoColor )
    {
        Abc_Print( 1, "  %s =%8d", p->pMuxes? "nod" : "and", Gia_ManAndNum(p) );
        Abc_Print( 1, "  lev =%5d", Gia_ManLevelNum(p) ); 
        Abc_Print( 1, " (%.2f)", Gia_ManLevelAve(p) ); 
    }
    else
    {
#ifdef WIN32
    {
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute( hConsole, 11 ); // blue
    Abc_Print( 1, "  %s =%8d", p->pMuxes? "nod" : "and", Gia_ManAndNum(p) );
    SetConsoleTextAttribute( hConsole, 13 ); // magenta
    Abc_Print( 1, "  lev =%5d", Gia_ManLevelNum(p) ); 
    Abc_Print( 1, " (%7.2f)", Gia_ManLevelAve(p) ); 
    SetConsoleTextAttribute( hConsole, 7 ); // normal
    }
#else
    Abc_Print( 1, "  %s%s =%8d%s",  "\033[1;36m", p->pMuxes? "nod" : "and", Gia_ManAndNum(p), "\033[0m" ); // blue
    Abc_Print( 1, "  %slev =%5d%s", "\033[1;35m", Gia_ManLevelNum(p), "\033[0m" ); // magenta
    Abc_Print( 1, " %s(%.2f)%s",    "\033[1;35m", Gia_ManLevelAve(p), "\033[0m" ); 
#endif
    }
    if ( !fHaveLevels ) 
        Vec_IntFreeP( &p->vLevels );
    if ( pPars && pPars->fCut )
        Abc_Print( 1, "  cut = %d(%d)", Gia_ManCrossCut(p, 0), Gia_ManCrossCut(p, 1) );
    Abc_Print( 1, "  mem =%5.2f MB", Gia_ManMemory(p)/(1<<20) );
    if ( Gia_ManHasChoices(p) )
        Abc_Print( 1, "  ch =%5d", Gia_ManChoiceNum(p) );
    if ( p->pManTime )
        Abc_Print( 1, "  box = %d", Gia_ManNonRegBoxNum(p) );
    if ( p->pManTime )
        Abc_Print( 1, "  bb = %d", Gia_ManBlackBoxNum(p) );
    if ( Gia_ManBufNum(p) )
        Abc_Print( 1, "  buf = %d", Gia_ManBufNum(p) );
    if ( Gia_ManXorNum(p) && p->pMuxes == NULL )
        Abc_Print( 1, "  xor = %d", Gia_ManXorNum(p) );
    if ( pPars && pPars->fMuxXor )
        printf( "\nXOR/MUX " ), Gia_ManPrintMuxStats( p );
    if ( pPars && pPars->fSwitch )
    {
        static int nPiPo = 0;
        static float PrevSwiTotal = 0;
        float SwiTotal = Gia_ManComputeSwitching( p, 48, 16, 0 );
        Abc_Print( 1, "  power =%8.1f", SwiTotal );
        if ( PrevSwiTotal > 0 && nPiPo == Gia_ManCiNum(p) + Gia_ManCoNum(p) )
            Abc_Print( 1, " %6.2f %%", 100.0*(PrevSwiTotal-SwiTotal)/PrevSwiTotal );
        else if ( PrevSwiTotal == 0 || nPiPo != Gia_ManCiNum(p) + Gia_ManCoNum(p) )
            PrevSwiTotal = SwiTotal, nPiPo = Gia_ManCiNum(p) + Gia_ManCoNum(p);
    }
//    Abc_Print( 1, "obj =%5d  ", Gia_ManObjNum(p) );
    Abc_Print( 1, "\n" );
 
//    Gia_ManSatExperiment( p );
    if ( p->pReprs && p->pNexts )
        Gia_ManEquivPrintClasses( p, 0, 0.0 );
    if ( Gia_ManHasMapping(p) && (pPars == NULL || !pPars->fSkipMap) )
        Gia_ManPrintMappingStats( p, pPars ? pPars->pDumpFile : NULL );
    else if ( pPars && pPars->pDumpFile )
        Gia_ManLogAigStats( p, pPars->pDumpFile );
    if ( pPars && pPars->fNpn && Gia_ManHasMapping(p) )
        Gia_ManPrintNpnClasses( p );
    if ( p->vPacking )
        Gia_ManPrintPackingStats( p );
    if ( p->vEdge1 )
        Gia_ManPrintEdges( p );
    if ( pPars && pPars->fLutProf && Gia_ManHasMapping(p) )
        Gia_ManPrintLutStats( p );
    if ( p->pPlacement )
        Gia_ManPrintPlacement( p );
//    if ( p->pManTime )
//        Tim_ManPrintStats( (Tim_Man_t *)p->pManTime, p->nAnd2Delay );
    Gia_ManPrintFlopClasses( p );
    Gia_ManPrintGateClasses( p );
    Gia_ManPrintObjClasses( p );
//    if ( p->vRegClasses )
//    {
//        printf( "The design has %d flops with the following class info: ", Vec_IntSize(p->vRegClasses) );
//        Vec_IntPrint( p->vRegClasses );
//    }
    if ( p->vInitClasses )
        Gia_ManPrintInitClasses( p->vInitClasses );
    // check integrity of boxes
    Gia_ManCheckIntegrityWithBoxes( p );
/*
    if ( Gia_ManRegBoxNum(p) )
    {
        int i, Limit = Vec_IntFindMax(p->vRegClasses);
        for ( i = 1; i <= Limit; i++ )
            printf( "%d ", Vec_IntCountEntry(p->vRegClasses, i) );
        printf( "\n" );
    }
*/
    if ( pPars && pPars->fTents )
    {
/*
        int k, Entry, Prev = 1;
        Vec_Int_t * vLimit = Vec_IntAlloc( 1000 );
        Gia_Man_t * pNew = Gia_ManUnrollDup( p, vLimit );
        Abc_Print( 1, "Tents:  " );
        Vec_IntForEachEntryStart( vLimit, Entry, k, 1 )
            Abc_Print( 1, "%d=%d  ", k, Entry-Prev ), Prev = Entry;
        Abc_Print( 1, " Unused=%d.", Gia_ManObjNum(p) - Gia_ManObjNum(pNew) );
        Abc_Print( 1, "\n" );
        Vec_IntFree( vLimit );
        Gia_ManStop( pNew );
*/
        Gia_ManPrintTents( p );
    }
    if ( pPars && pPars->fSlacks )
        Gia_ManDfsSlacksPrint( p );
    if ( Gia_ManHasMapping(p) && pPars->fMapOutStats )
        Gia_ManPrintOutputLutStats( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintStatsMiter()

void Gia_ManPrintStatsMiter	(	Gia_Man_t *	p,
		int	fVerbose )

extern

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

Synopsis [Statistics of the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 730 of file giaMan.c.

{
    Gia_Obj_t * pObj;
    Vec_Flt_t * vProb;
    int i, iObjId;
    Gia_ManLevelNum( p );
    Gia_ManCreateRefs( p );
    vProb = Gia_ManPrintOutputProb( p );
    printf( "Statistics for each outputs of the miter:\n" );
    Gia_ManForEachPo( p, pObj, i )
    {
        iObjId = Gia_ObjId(p, pObj);
        printf( "%4d : ", i );
        printf( "Level = %5d  ",  Gia_ObjLevelId(p, iObjId) );
        printf( "Supp = %5d  ",   Gia_ManSuppSize(p, &iObjId, 1) );
        printf( "Cone = %5d  ",   Gia_ManConeSize(p, &iObjId, 1) );
        printf( "Mffc = %5d  ",   Gia_NodeMffcSize(p, Gia_ObjFanin0(pObj)) );
        printf( "Prob = %8.4f  ", Vec_FltEntry(vProb, iObjId) );
        printf( "\n" );
    }
    Vec_FltFree( vProb );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManPrintStatsShort()

void Gia_ManPrintStatsShort ( Gia_Man_t * p )

extern

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 658 of file giaMan.c.

{
    Abc_Print( 1, "i/o =%7d/%7d  ", Gia_ManPiNum(p), Gia_ManPoNum(p) );
    Abc_Print( 1, "ff =%7d  ", Gia_ManRegNum(p) );
    Abc_Print( 1, "and =%8d  ", Gia_ManAndNum(p) );
    Abc_Print( 1, "lev =%5d  ", Gia_ManLevelNum(p) );
//    Abc_Print( 1, "mem =%5.2f MB", 12.0*Gia_ManObjNum(p)/(1<<20) );
    Abc_Print( 1, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManProdAdderGen()

void Gia_ManProdAdderGen	(	int	nArgA,
		int	nArgB,
		int	Seed,
		int	fSigned,
		int	fCla )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 5609 of file giaDup.c.

{
    extern void Wlc_BlastReduceMatrix( Gia_Man_t * pNew, Vec_Wec_t * vProds, Vec_Wec_t * vLevels, Vec_Int_t * vRes, int fSigned, int fCla );
    int i, k, x, fCompl, iLit; char  pNameP[32], pNameT[32];
    Vec_Wec_t * vProds  = Vec_WecStart( nArgA + nArgB );
    Vec_Wec_t * vLevels = Vec_WecStart( nArgA + nArgB );
    Vec_Int_t * vRes = Vec_IntAlloc( nArgA + nArgB );
    Vec_Int_t * vArgA = Vec_IntAlloc( nArgA );
    Vec_Int_t * vArgB = Vec_IntAlloc( nArgB ), * vLevel;
    Gia_Man_t * pProd = Gia_ManStart( 1000 );
    Gia_Man_t * pTree = Gia_ManStart( 1000 ), * pTemp;
    Gia_ManHashAlloc( pTree );
    pProd->pName = Abc_UtilStrsav( "prod" );
    pTree->pName = Abc_UtilStrsav( "tree" );
    for ( x = 0; x < nArgA; x++ )
        Vec_IntPush( vArgA, Gia_ManAppendCi(pProd) );
    for ( x = 0; x < nArgB; x++ )
        Vec_IntPush( vArgB, Gia_ManAppendCi(pProd) );
    for ( x = 0; x < nArgA + nArgB; x++ )
    {
        for ( i = 0; i < nArgA; i++ )
        for ( k = 0; k < nArgB; k++ )
        {
            if ( i + k != x )
                continue;
            fCompl = fSigned && ((i == nArgA-1) ^ (k == nArgB-1));
            iLit = Abc_LitNotCond(Gia_ManAppendAnd(pProd, Vec_IntEntry(vArgA, i), Vec_IntEntry(vArgB, k)), fCompl);
            Gia_ManAppendCo( pProd, iLit );
            Vec_WecPush( vProds,  i+k, Gia_ManAppendCi(pTree) );
            Vec_WecPush( vLevels, i+k, 0 );
        }
    }
    if ( fSigned )
    {
        Vec_WecPush( vProds,  nArgA, 1 );
        Vec_WecPush( vLevels, nArgA, 0 );
 
        Vec_WecPush( vProds,  nArgA+nArgB-1, 1 );
        Vec_WecPush( vLevels, nArgA+nArgB-1, 0 );
    }
    if ( Seed )
    {
        Abc_Random( 1 );
        for ( x = 0; x < Seed; x++ )
            Abc_Random( 0 );
        Vec_WecForEachLevel( vProds, vLevel, x )
            if ( Vec_IntSize(vLevel) > 1 )
                Vec_IntRandomizeOrder( vLevel );
    }
    Wlc_BlastReduceMatrix( pTree, vProds, vLevels, vRes, fSigned, fCla );
    Vec_IntShrink( vRes, nArgA + nArgB );
    assert( Vec_IntSize(vRes) == nArgA + nArgB );
    Vec_IntForEachEntry( vRes, iLit, x )
        Gia_ManAppendCo( pTree, iLit );
    pTree = Gia_ManCleanup( pTemp = pTree );
    Gia_ManStop( pTemp );
 
    sprintf( pNameP, "prod%d%d.aig", nArgA, nArgB );
    sprintf( pNameT, "tree%d%d.aig", nArgA, nArgB );
    Gia_AigerWrite( pProd, pNameP, 0, 0, 0 );
    Gia_AigerWrite( pTree, pNameT, 0, 0, 0 );
    Gia_ManStop( pProd );
    Gia_ManStop( pTree );
    printf( "Dumped files \"%s\" and \"%s\".\n", pNameP, pNameT );
 
    Vec_WecFree( vProds );
    Vec_WecFree( vLevels );
    Vec_IntFree( vArgA );
    Vec_IntFree( vArgB );
    Vec_IntFree( vRes );
}

Here is the call graph for this function:

◆ Gia_ManPtrWrdDumpBin()

void Gia_ManPtrWrdDumpBin	(	char *	pFileName,
		Vec_Ptr_t *	p,
		int	fVerbose )

extern

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

Synopsis [Serialization.]

Description []

SideEffects []

SeeAlso []

Definition at line 2660 of file giaSimBase.c.

{
    Vec_Wrd_t * vLevel;
    int i, nSize, RetValue;
    FILE * pFile = fopen( pFileName, "wb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open file \"%s\" for writing.\n", pFileName );
        return;
    }
    nSize = Vec_PtrSize(p);
    RetValue = fwrite( &nSize, 1, sizeof(int), pFile );
    Vec_PtrForEachEntry( Vec_Wrd_t *, p, vLevel, i )
    {
        nSize = Vec_WrdSize(vLevel);
        RetValue += fwrite( &nSize, 1, sizeof(int), pFile );
        RetValue += fwrite( Vec_WrdArray(vLevel), 1, sizeof(word)*nSize, pFile );
    }
    fclose( pFile );
    if ( fVerbose )
        printf( "Written %d arrays into file \"%s\".\n", Vec_PtrSize(p), pFileName );
}

◆ Gia_ManPtrWrdReadBin()

Vec_Ptr_t * Gia_ManPtrWrdReadBin	(	char *	pFileName,
		int	fVerbose )

extern

Definition at line 2682 of file giaSimBase.c.

{
    Vec_Ptr_t * p = NULL; Vec_Wrd_t * vLevel; int i, nSize, RetValue;
    FILE * pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open file \"%s\" for reading.\n", pFileName );
        return NULL;
    }
    fseek( pFile, 0, SEEK_END );
    nSize = ftell( pFile );
    if ( nSize == 0 )
    {
        printf( "The input file is empty.\n" );
        fclose( pFile );
        return NULL;
    }
    if ( nSize % (int)sizeof(int) > 0 )
    {
        printf( "Cannot read file with integers because it is not aligned at 4 bytes (remainder = %d).\n", nSize % (int)sizeof(int) );
        fclose( pFile );
        return NULL;
    }
    rewind( pFile );
    RetValue = fread( &nSize, 1, sizeof(int), pFile );
    assert( RetValue == 4 );
    p = Vec_PtrAlloc( nSize );
    for ( i = 0; i < nSize; i++ )
        Vec_PtrPush( p, Vec_WrdAlloc(100) );
    Vec_PtrForEachEntry( Vec_Wrd_t *, p, vLevel, i )
    {
        RetValue = fread( &nSize, 1, sizeof(int), pFile );
        assert( RetValue == 4 );
        Vec_WrdFill( vLevel, nSize, 0 );
        RetValue = fread( Vec_WrdArray(vLevel), 1, sizeof(word)*nSize, pFile );
        assert( RetValue == 8*nSize );
    }
    fclose( pFile );
    if ( fVerbose )
        printf( "Read %d arrays from file \"%s\".\n", Vec_PtrSize(p), pFileName );
    return p;
}

Here is the call graph for this function:

◆ Gia_ManQuantExist()

int Gia_ManQuantExist	(	Gia_Man_t *	p,
		int	iLit,
		int(*	pFuncCiToKeep )(void *, int),
		void *	pData )

extern

Definition at line 505 of file giaExist.c.

{
    int Res;
    Vec_Int_t * vQuantCis  = Vec_IntAlloc( 100 );
    Vec_Int_t * vQuantSide = Vec_IntAlloc( 100 );
    Vec_Int_t * vQuantAnds = Vec_IntAlloc( 100 );
    Gia_ManQuantCollect( p0, Abc_Lit2Var(iLit), pFuncCiToKeep, pData, vQuantCis, vQuantSide, vQuantAnds );
    Res = Gia_ManQuantExistInt( p0, iLit, vQuantCis, vQuantSide, vQuantAnds );
    Vec_IntFree( vQuantCis );
    Vec_IntFree( vQuantSide );
    Vec_IntFree( vQuantAnds );
    return Res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManQuantSetSuppAnd()

void Gia_ManQuantSetSuppAnd	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

Definition at line 144 of file giaExist.c.

{
    int iObj  = Gia_ObjId(p, pObj);
    int iFan0 = Gia_ObjFaninId0(pObj, iObj);
    int iFan1 = Gia_ObjFaninId1(pObj, iObj);
    assert( Gia_ObjIsAnd(pObj) );
    Gia_ManQuantSetSuppZero( p );
    Abc_TtOr( Gia_ManQuantInfo(p, pObj), Gia_ManQuantInfoId(p, iFan0), Gia_ManQuantInfoId(p, iFan1), p->nSuppWords );
}

Here is the call graph for this function:

◆ Gia_ManQuantSetSuppCi()

void Gia_ManQuantSetSuppCi	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

Definition at line 117 of file giaExist.c.

{
    assert( Gia_ObjIsCi(pObj) );
    assert( p->vSuppWords != NULL );
    if ( p->iSuppPi == 64 * p->nSuppWords )
    {
        word Data; int w, Count = 0, Size = Vec_WrdSize(p->vSuppWords);
        Vec_Wrd_t * vTemp = Vec_WrdAlloc( Size ? 2 * Size : 1000 ); 
        Vec_WrdForEachEntry( p->vSuppWords, Data, w )
        {
            Vec_WrdPush( vTemp, Data );
            if ( ++Count == p->nSuppWords )
            {
                Vec_WrdPush( vTemp, 0 );
                Count = 0;
            }
        }
        Vec_WrdFree( p->vSuppWords );
        p->vSuppWords = vTemp;
        p->nSuppWords++;
        assert( Vec_WrdSize(p->vSuppWords) == p->nSuppWords * Gia_ManObjNum(p) );
        //printf( "Resizing to %d words.\n", p->nSuppWords );
    }
    assert( p->iSuppPi == Vec_IntSize(&p->vSuppVars) );
    Vec_IntPush( &p->vSuppVars, Gia_ObjCioId(pObj) );
    Abc_TtSetBit( Gia_ManQuantInfo(p, pObj), p->iSuppPi++ );
}

Here is the caller graph for this function:

◆ Gia_ManQuantSetSuppStart()

void Gia_ManQuantSetSuppStart ( Gia_Man_t * p )

extern

Definition at line 100 of file giaExist.c.

{
    assert( Gia_ManObjNum(p) == 1 );
    assert( p->vSuppWords == NULL );
    assert( Vec_IntSize(&p->vSuppVars) == 0 );
    p->iSuppPi    = 0;
    p->nSuppWords = 1;
    p->vSuppWords = Vec_WrdAlloc( 1000 );
    Vec_WrdPush( p->vSuppWords, 0 );
}

Here is the caller graph for this function:

◆ Gia_ManQuantSetSuppZero()

void Gia_ManQuantSetSuppZero ( Gia_Man_t * p )

extern

Definition at line 110 of file giaExist.c.

{
    int w;
    for ( w = 0; w < p->nSuppWords; w++ )
        Vec_WrdPush( p->vSuppWords, 0 );
    assert( Vec_WrdSize(p->vSuppWords) == p->nSuppWords * Gia_ManObjNum(p) );
}

Here is the caller graph for this function:

◆ Gia_ManQuantUpdateCiSupp()

void Gia_ManQuantUpdateCiSupp	(	Gia_Man_t *	p,
		int	iObj )

extern

Definition at line 157 of file giaExist.c.

{
    if ( Abc_TtIsConst0( Gia_ManQuantInfoId(p, iObj), p->nSuppWords ) )
        Gia_ManQuantSetSuppCi( p, Gia_ManObj(p, iObj) );
    assert( !Abc_TtIsConst0( Gia_ManQuantInfoId(p, iObj), p->nSuppWords ) );
}

Here is the call graph for this function:

◆ Gia_ManRandom()

unsigned Gia_ManRandom ( int fReset )

extern

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 )

extern

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 )

extern

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_ManReadMiniAig()

Gia_Man_t * Gia_ManReadMiniAig	(	char *	pFileName,
		int	fGiaSimple )

extern

Definition at line 220 of file giaMini.c.

{
    Mini_Aig_t * p = Mini_AigLoad( pFileName );
    Gia_Man_t * pTemp, * pGia = Gia_ManFromMiniAig( p, NULL, fGiaSimple );
    ABC_FREE( pGia->pName );
    pGia->pName = Extra_FileNameGeneric( pFileName ); 
    Mini_AigStop( p );
    Gia_ManReadMiniAigNames( pFileName, pGia );
    if ( !Gia_ManIsNormalized(pGia) )
    {
        pGia = Gia_ManDupNormalize( pTemp = pGia, 0 );
        ABC_SWAP( Vec_Ptr_t *, pTemp->vNamesIn,  pGia->vNamesIn  );
        ABC_SWAP( Vec_Ptr_t *, pTemp->vNamesOut, pGia->vNamesOut );
        Gia_ManStop( pTemp );
    }
    return pGia;
}

Here is the call graph for this function:

◆ Gia_ManReadMiniLut()

Gia_Man_t * Gia_ManReadMiniLut ( char * pFileName )

extern

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

Synopsis [Procedures to read/write GIA to/from MiniAIG file.]

Description []

SideEffects []

SeeAlso []

Definition at line 587 of file giaMini.c.

{
    Mini_Lut_t * p = Mini_LutLoad( pFileName );
    Gia_Man_t * pGia = Gia_ManFromMiniLut( p, NULL );
    ABC_FREE( pGia->pName );
    pGia->pName = Extra_FileNameGeneric( pFileName ); 
    Mini_LutStop( p );
    return pGia;
}

Here is the call graph for this function:

◆ Gia_ManReduceConst()

Gia_Man_t * Gia_ManReduceConst	(	Gia_Man_t *	pAig,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 737 of file giaTsim.c.

{
    Gia_ManTer_t * p;
    Gia_Man_t * pNew = NULL;
    int * pCi2Lit;
    p = Gia_ManTerSimulate( pAig, fVerbose );
    Gia_ManTerAnalyze( p );
    pCi2Lit = Gia_ManTerCreateMap( p, fVerbose );
    Gia_ManTerDelete( p );
    pNew = Gia_ManDupDfsCiMap( pAig, pCi2Lit, NULL );
    ABC_FREE( pCi2Lit );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManRegBoxNum()

int Gia_ManRegBoxNum ( Gia_Man_t * p )

extern

Definition at line 54 of file giaTim.c.

{
    return p->vRegClasses ? Vec_IntSize(p->vRegClasses) : 0;
}

Here is the caller graph for this function:

◆ Gia_ManRehash()

Gia_Man_t * Gia_ManRehash	(	Gia_Man_t *	p,
		int	fAddStrash )

extern

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

Synopsis [Rehashes AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 739 of file giaHash.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->fAddStrash = fAddStrash;
    Gia_ManHashAlloc( pNew );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj( p, pObj, i )
    {
        //if ( Gia_ObjIsBuf(pObj) )
        //    pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        //else 
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsCo(pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManHashStop( pNew );
    pNew->fAddStrash = 0;
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
//    printf( "Top gate is %s\n", Gia_ObjFaninC0(Gia_ManCo(pNew, 0))? "OR" : "AND" );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManRemoveEnables()

Gia_Man_t * Gia_ManRemoveEnables ( Gia_Man_t * p )

extern

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

Synopsis [Transform seq circuits with enables by removing enables.]

Description []

SideEffects []

SeeAlso []

Definition at line 514 of file giaEnable.c.

{
    Vec_Ptr_t * vCtrls, * vDatas;
    Vec_Int_t * vFlopClasses;
    Gia_Man_t * pNew, * pAux; 
    Gia_Obj_t * pFlopIn, * pFlopOut, * pDriver, * pFan0, * pFan1, * pCtrl = NULL, * pData, * pObj;
    int i, iClass, fCompl, Counter = 0;
    vCtrls = Vec_PtrAlloc( 100 );
    Vec_PtrPush( vCtrls, NULL );
    vDatas = Vec_PtrAlloc( Gia_ManRegNum(p) );
    vFlopClasses = Vec_IntAlloc( Gia_ManRegNum(p) );
    Gia_ManForEachRi( p, pFlopIn, i )
    {
        fCompl = Gia_ObjFaninC0(pFlopIn);
        pDriver = Gia_ObjFanin0(pFlopIn);
        if ( !Gia_ObjIsAnd(pDriver) )
        {
            printf( "The flop driver %d is not a node.\n", i );
            Vec_PtrPush( vDatas, NULL );
            Vec_IntPush( vFlopClasses, 0 );
            Counter++;
            continue;
        }
        if ( !Gia_ObjFaninC0(pDriver) || !Gia_ObjFaninC1(pDriver) )
        {
            printf( "The flop driver %d is not an OR gate.\n", i );
            Vec_PtrPush( vDatas, NULL );
            Vec_IntPush( vFlopClasses, 0 );
            Counter++;
            continue;
        }
        pFan0 = Gia_ObjFanin0(pDriver);
        pFan1 = Gia_ObjFanin1(pDriver);
        if ( !Gia_ObjIsAnd(pFan0) || !Gia_ObjIsAnd(pFan1) )
        {
            printf( "The flop driver fanin %d is not a node.\n", i );
            Vec_PtrPush( vDatas, NULL );
            Vec_IntPush( vFlopClasses, 0 );
            Counter++;
            continue;
        }
        pFlopOut = Gia_ObjRiToRo( p, pFlopIn );
        pFlopOut = Gia_NotCond( pFlopOut, !fCompl );
        if ( Gia_ObjChild0(pFan0) != pFlopOut && Gia_ObjChild1(pFan0) != pFlopOut && 
             Gia_ObjChild0(pFan1) != pFlopOut && Gia_ObjChild1(pFan1) != pFlopOut )
        {
            printf( "The flop %d does not have a self-loop.\n", i );
            Vec_PtrPush( vDatas, NULL );
            Vec_IntPush( vFlopClasses, 0 );
            Counter++;
            continue;
        }
        pData = NULL;
        if ( Gia_ObjChild0(pFan0) == pFlopOut )
        {
            pCtrl = Gia_Not( Gia_ObjChild1(pFan0) );
            if ( Gia_ObjFanin0(pFan1) == Gia_Regular(pCtrl) )
                pData = Gia_ObjChild1(pFan1);
            else
                pData = Gia_ObjChild0(pFan1);
        }
        else if ( Gia_ObjChild1(pFan0) == pFlopOut )
        {
            pCtrl = Gia_Not( Gia_ObjChild0(pFan0) );
            if ( Gia_ObjFanin0(pFan1) == Gia_Regular(pCtrl) )
                pData = Gia_ObjChild1(pFan1);
            else
                pData = Gia_ObjChild0(pFan1);
        }
        else if ( Gia_ObjChild0(pFan1) == pFlopOut )
        {
            pCtrl = Gia_Not( Gia_ObjChild1(pFan1) );
            if ( Gia_ObjFanin0(pFan0) == Gia_Regular(pCtrl) )
                pData = Gia_ObjChild1(pFan0);
            else
                pData = Gia_ObjChild0(pFan0);
        }
        else if ( Gia_ObjChild1(pFan1) == pFlopOut )
        {
            pCtrl = Gia_Not( Gia_ObjChild0(pFan1) );
            if ( Gia_ObjFanin0(pFan0) == Gia_Regular(pCtrl) )
                pData = Gia_ObjChild1(pFan0);
            else
                pData = Gia_ObjChild0(pFan0);
        }
        else assert( 0 );
        if ( Vec_PtrFind( vCtrls, pCtrl ) == -1 )
            Vec_PtrPush( vCtrls, pCtrl );
        iClass = Vec_PtrFind( vCtrls, pCtrl );
        pData = Gia_NotCond( pData, !fCompl );
        Vec_PtrPush( vDatas, pData );
        Vec_IntPush( vFlopClasses, iClass );
    }
    assert( Vec_PtrSize( vDatas ) == Gia_ManRegNum(p) );
    assert( Vec_IntSize( vFlopClasses ) == Gia_ManRegNum(p) );
    printf( "Detected %d classes.\n", Vec_PtrSize(vCtrls) - (Counter == 0) );
    Vec_PtrFree( vCtrls );
    
 
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachObj1( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) )
            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
        else if ( Gia_ObjIsCi(pObj) )
            pObj->Value = Gia_ManAppendCi( pNew );
        else if ( Gia_ObjIsPo(p, pObj) )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Gia_ManForEachRi( p, pObj, i )
    {
        pData = (Gia_Obj_t *)Vec_PtrEntry(vDatas, i);
        if ( pData == NULL )
            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        else
            pObj->Value = Gia_ManAppendCo( pNew, Abc_LitNotCond(Gia_Regular(pData)->Value, Gia_IsComplement(pData)) );
    }
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    Vec_PtrFree( vDatas );
 
 
    pNew = Gia_ManCleanup( pAux = pNew );
    Gia_ManStop( pAux );
    pNew->vFlopClasses = vFlopClasses;
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManReportImprovement()

void Gia_ManReportImprovement	(	Gia_Man_t *	p,
		Gia_Man_t *	pNew )

extern

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

Synopsis [Reports the reduction of the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 782 of file giaMan.c.

{
    Abc_Print( 1, "REG: Beg = %5d. End = %5d. (R =%5.1f %%)  ",
        Gia_ManRegNum(p), Gia_ManRegNum(pNew),
        Gia_ManRegNum(p)? 100.0*(Gia_ManRegNum(p)-Gia_ManRegNum(pNew))/Gia_ManRegNum(p) : 0.0 );
    Abc_Print( 1, "AND: Beg = %6d. End = %6d. (R =%5.1f %%)",
        Gia_ManAndNum(p), Gia_ManAndNum(pNew),
        Gia_ManAndNum(p)? 100.0*(Gia_ManAndNum(p)-Gia_ManAndNum(pNew))/Gia_ManAndNum(p) : 0.0 );
    Abc_Print( 1, "\n" );
}

Here is the caller graph for this function:

◆ Gia_ManRequiredLevel()

Vec_Int_t * Gia_ManRequiredLevel ( Gia_Man_t * p )

extern

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_ManRetimeForward()

Gia_Man_t * Gia_ManRetimeForward	(	Gia_Man_t *	p,
		int	nMaxIters,
		int	fVerbose )

extern

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

Synopsis [Derives the cut for forward retiming.]

Description [Assumes topological ordering of the nodes.]

SideEffects []

SeeAlso []

Definition at line 267 of file giaRetime.c.

{
    Gia_Man_t * pNew, * pTemp;
    int i, nRegFixed, nRegMoves = 1;
    abctime clk;
    pNew = p;
    for ( i = 0; i < nMaxIters && nRegMoves > 0; i++ )
    {
        clk = Abc_Clock();
        pNew = Gia_ManRetimeForwardOne( pTemp = pNew, &nRegFixed, &nRegMoves );
        if ( fVerbose )
        {
            printf( "%2d : And = %6d. Reg = %5d. Unret = %5d. Move = %6d. ", 
                i + 1, Gia_ManAndNum(pTemp), Gia_ManRegNum(pTemp), nRegFixed, nRegMoves );
            ABC_PRT( "Time", Abc_Clock() - clk );
        }
        if ( pTemp != p )
            Gia_ManStop( pTemp );
    }
/*
    clk = Abc_Clock();
    pNew = Gia_ManReduceLaches( pNew, fVerbose );
    if ( fVerbose )
    {
        ABC_PRT( "Register sharing time", Abc_Clock() - clk );
    }
*/
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManReverseLevel()

Vec_Int_t * Gia_ManReverseLevel ( Gia_Man_t * p )

extern

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_ManRrr()

Gia_Man_t * Gia_ManRrr	(	Gia_Man_t *	pGia,
		int	iSeed,
		int	nWords,
		int	nTimeout,
		int	nSchedulerVerbose,
		int	nPartitionerVerbose,
		int	nOptimizerVerbose,
		int	nAnalyzerVerbose,
		int	nSimulatorVerbose,
		int	nSatSolverVerbose,
		int	fUseBddCspf,
		int	fUseBddMspf,
		int	nConflictLimit,
		int	nSortType,
		int	nOptimizerFlow,
		int	nSchedulerFlow,
		int	nPartitionType,
		int	nDistance,
		int	nJobs,
		int	nThreads,
		int	nPartitionSize,
		int	nPartitionSizeMin,
		int	fDeterministic,
		int	nParallelPartitions,
		int	fOptOnInsert,
		int	fGreedy )

extern

Definition at line 8 of file giaRrr.cpp.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       {
  rrr::AndNetwork ntk;
  ntk.Read(pGia, rrr::GiaReader<rrr::AndNetwork>);
  rrr::Parameter Par;
  Par.iSeed = iSeed;
  Par.nWords = nWords;
  Par.nTimeout = nTimeout;
  Par.nSchedulerVerbose = nSchedulerVerbose;
  Par.nPartitionerVerbose = nPartitionerVerbose;
  Par.nOptimizerVerbose = nOptimizerVerbose;
  Par.nAnalyzerVerbose = nAnalyzerVerbose;
  Par.nSimulatorVerbose = nSimulatorVerbose;
  Par.nSatSolverVerbose = nSatSolverVerbose;
  Par.fUseBddCspf = fUseBddCspf;
  Par.fUseBddMspf = fUseBddMspf;
  Par.nConflictLimit = nConflictLimit;
  Par.nSortType = nSortType;
  Par.nOptimizerFlow = nOptimizerFlow;
  Par.nSchedulerFlow = nSchedulerFlow;
  Par.nPartitionType = nPartitionType;
  Par.nDistance = nDistance;
  Par.nJobs = nJobs;
  Par.nThreads = nThreads;
  Par.nPartitionSize = nPartitionSize;
  Par.nPartitionSizeMin = nPartitionSizeMin;
  Par.fDeterministic = fDeterministic;
  Par.nParallelPartitions = nParallelPartitions;
  Par.fOptOnInsert = fOptOnInsert;
  Par.fGreedy = fGreedy;
  rrr::Perform(&ntk, &Par);
  Gia_Man_t *pNew = rrr::CreateGia(&ntk, false);
  return pNew;
}

Here is the call graph for this function:

◆ Gia_ManSaveValue()

Vec_Int_t * Gia_ManSaveValue ( Gia_Man_t * p )

extern

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_ManSeqCleanup()

Gia_Man_t * Gia_ManSeqCleanup ( Gia_Man_t * p )

extern

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

Synopsis [Performs sequential cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 183 of file giaScl.c.

{
    Gia_ManSeqMarkUsed( p );
    return Gia_ManDupMarked( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSeqMarkUsed()

int Gia_ManSeqMarkUsed ( Gia_Man_t * p )

extern

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

Synopsis [Marks CIs/COs/ANDs unreachable from POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 156 of file giaScl.c.

{
    Vec_Int_t * vRoots;
    Gia_Obj_t * pObj;
    int i, nNodes = 0;
    Gia_ManSetMark0( p );
    Gia_ManConst0(p)->fMark0 = 0;
    Gia_ManForEachPi( p, pObj, i )
        pObj->fMark0 = 0;
    vRoots = Gia_ManCollectPoIds( p );
    Gia_ManForEachObjVec( vRoots, p, pObj, i )
        nNodes += Gia_ManSeqMarkUsed_rec( p, pObj, vRoots );
    Vec_IntFree( vRoots );
    return nNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSeqStructSweep()

Gia_Man_t * Gia_ManSeqStructSweep	(	Gia_Man_t *	p,
		int	fConst,
		int	fEquiv,
		int	fVerbose )

extern

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

Synopsis [Performs sequential cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 258 of file giaScl.c.

{
    Gia_Man_t * pTemp;
    if ( Gia_ManRegNum(p) == 0 )
        return Gia_ManCleanup( p );
    if ( fVerbose )
        printf( "Performing sequential cleanup.\n" );
    p = Gia_ManSeqCleanup( pTemp = p );
    if ( fVerbose )
        Gia_ManReportImprovement( pTemp, p );
    if ( fConst && Gia_ManRegNum(p) )
    {
        p = Gia_ManReduceConst( pTemp = p, fVerbose );
        if ( fVerbose )
            Gia_ManReportImprovement( pTemp, p );
        Gia_ManStop( pTemp );
    }
    if ( fVerbose && fEquiv )
        printf( "Merging combinationally equivalent flops.\n" );
    if ( fEquiv )
    while ( 1 )
    {
        p = Gia_ManSeqCleanup( pTemp = p );
        if ( fVerbose )
            Gia_ManReportImprovement( pTemp, p );
        Gia_ManStop( pTemp );
        if ( Gia_ManRegNum(p) == 0 )
            break;
        p = Gia_ManReduceEquiv( pTemp = p, fVerbose );
        if ( p == pTemp )
            break;
        Gia_ManStop( pTemp );
    }
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSetFailedPoCex()

int Gia_ManSetFailedPoCex	(	Gia_Man_t *	pAig,
		Abc_Cex_t *	p )

extern

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

Synopsis [Determines the failed PO when its exact frame is not known.]

Description []

SideEffects []

SeeAlso []

Definition at line 139 of file giaCex.c.

{
    Gia_Obj_t * pObj, * pObjRi, * pObjRo;
    int i, k, iBit = 0;
    assert( Gia_ManPiNum(pAig) == p->nPis );
    Gia_ManCleanMark0(pAig);
    p->iPo = -1;
//    Gia_ManForEachRo( pAig, pObj, i )
//       pObj->fMark0 = Abc_InfoHasBit(p->pData, iBit++);
    iBit = p->nRegs;
    for ( i = 0; i <= p->iFrame; i++ )
    {
        Gia_ManForEachPi( pAig, pObj, k )
            pObj->fMark0 = Abc_InfoHasBit(p->pData, iBit++);
        Gia_ManForEachAnd( pAig, pObj, k )
            pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & 
                           (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
        Gia_ManForEachCo( pAig, pObj, k )
            pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj);
        Gia_ManForEachRiRo( pAig, pObjRi, pObjRo, k )
            pObjRo->fMark0 = pObjRi->fMark0;
        // check the POs
        Gia_ManForEachPo( pAig, pObj, k )
        {
            if ( !pObj->fMark0 )
                continue;
            p->iPo = k;
            p->iFrame = i;
            p->nBits = iBit;
            break;
        }
    }
    Gia_ManCleanMark0(pAig);
    return p->iPo;
}

Here is the call graph for this function:

◆ Gia_ManSetIfParsDefault()

void Gia_ManSetIfParsDefault ( void * pp )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Load the network into FPGA manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 59 of file giaIf.c.

{
    If_Par_t * pPars = (If_Par_t *)pp;
//    extern void * Abc_FrameReadLibLut();
    If_Par_t * p = (If_Par_t *)pPars;
    // set defaults
    memset( p, 0, sizeof(If_Par_t) );
    // user-controlable paramters
    p->nLutSize    = -1;
//    p->nLutSize    =  6;
    p->nCutsMax    =  8;
    p->nFlowIters  =  1;
    p->nAreaIters  =  2;
    p->DelayTarget = -1;
    p->Epsilon     =  (float)0.005;
    p->fPreprocess =  1;
    p->fArea       =  0;
    p->fFancy      =  0;
    p->fExpRed     =  1; 
    p->fLatchPaths =  0;
    p->fEdge       =  1;
    p->fPower      =  0;
    p->fCutMin     =  0;
    p->fVerbose    =  0;
    p->pLutStruct  =  NULL;
    // internal parameters
    p->fTruth      =  0;
    p->nLatchesCi  =  0;
    p->nLatchesCo  =  0;
    p->fLiftLeaves =  0;
    p->fUseCoAttrs =  1;   // use CO attributes
    p->pLutLib     =  NULL;
    p->pTimesArr   =  NULL; 
    p->pTimesReq   =  NULL;   
    p->pFuncCost   =  NULL;   
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSetLevels()

int Gia_ManSetLevels	(	Gia_Man_t *	p,
		Vec_Int_t *	vCiLevels )

extern

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_ManSetLutRefs()

void Gia_ManSetLutRefs ( Gia_Man_t * p )

extern

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 295 of file giaIf.c.

{
    Gia_Obj_t * pObj;
    int i, k, iFan;
    ABC_FREE( p->pLutRefs );
    p->pLutRefs = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ObjLutRefIncId( p, Gia_ObjFaninId0p(p, pObj) );
    Gia_ManForEachLut( p, i )
        Gia_LutForEachFanin( p, i, iFan, k )
            Gia_ObjLutRefIncId( p, iFan );
}

Here is the caller graph for this function:

◆ Gia_ManSetMark0()

void Gia_ManSetMark0 ( Gia_Man_t * p )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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_ManSetRefsMapped()

void Gia_ManSetRefsMapped ( Gia_Man_t * p )

extern

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 271 of file giaIf.c.

{
    Gia_Obj_t * pObj;
    int i, k, iFan;
    ABC_FREE( p->pRefs );
    p->pRefs = ABC_CALLOC( int, Gia_ManObjNum(p) );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ObjRefIncId( p, Gia_ObjFaninId0p(p, pObj) );
    Gia_ManForEachLut( p, i )
        Gia_LutForEachFanin( p, i, iFan, k )
            Gia_ObjRefIncId( p, iFan );
}

Here is the caller graph for this function:

◆ Gia_ManSetRegNum()

void Gia_ManSetRegNum	(	Gia_Man_t *	p,
		int	nRegs )

extern

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 764 of file giaMan.c.

{
    assert( p->nRegs == 0 );
    p->nRegs = nRegs;
}

◆ Gia_ManShow()

void Gia_ManShow	(	Gia_Man_t *	pMan,
		Vec_Int_t *	vBold,
		int	fAdders,
		int	fFadds,
		int	fPath )

extern

Definition at line 1126 of file giaShow.c.

{
    extern void Abc_ShowFile( char * FileNameDot, int fKeepDot );
    char FileNameDot[200];
    FILE * pFile;
    Vec_Int_t * vXors = NULL, * vAdds = fAdders ? Ree_ManComputeCuts( pMan, &vXors, 0 ) : NULL;
    sprintf( FileNameDot, "%s", Extra_FileNameGenericAppend(pMan->pName ? pMan->pName : (char *)"unknown", ".dot") );
    // check that the file can be opened
    if ( (pFile = fopen( FileNameDot, "w" )) == NULL )
    {
        fprintf( stdout, "Cannot open the intermediate file \"%s\".\n", FileNameDot );
        return;
    }
    fclose( pFile );
    // generate the file
    if ( fPath )
        Gia_ShowPath( pMan, FileNameDot );
    else if ( fAdders )
        Gia_ShowProcess( pMan, FileNameDot, vBold, vAdds, vXors, fFadds );
    else
        Gia_WriteDotAigSimple( pMan, FileNameDot, vBold );
    // visualize the file 
    Abc_ShowFile( FileNameDot, 0 );
 
    Vec_IntFreeP( &vAdds );
    Vec_IntFreeP( &vXors );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSim2Array()

Vec_Wec_t * Gia_ManSim2Array ( Vec_Ptr_t * vSims )

extern

Definition at line 2570 of file giaSimBase.c.

{
    Vec_Wec_t * vRes = Vec_WecStart( Vec_PtrSize(vSims) );
    Vec_Int_t * vLevel; int i;
    Vec_WecForEachLevel( vRes, vLevel, i )
        Gia_ManSim2ArrayOne( (Vec_Wrd_t *)Vec_PtrEntry(vSims, i), vLevel );
    return vRes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSim2ArrayOne()

void Gia_ManSim2ArrayOne	(	Vec_Wrd_t *	vSimsPi,
		Vec_Int_t *	vRes )

extern

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

Synopsis [Serialization.]

Description []

SideEffects []

SeeAlso []

Definition at line 2558 of file giaSimBase.c.

{
    word * pInfo = Vec_WrdArray(vSimsPi); int w, i;
    word * pCare = pInfo + Vec_WrdSize(vSimsPi);
    Vec_IntClear( vRes );
    for ( w = 0; w < Vec_WrdSize(vSimsPi); w++ )
        if ( pCare[w] )
            for ( i = 0; i < 64; i++ )
                if ( Abc_TtGetBit(pCare, w*64+i) )
                    Vec_IntPush( vRes, Abc_Var2Lit(w*64+i, Abc_TtGetBit(pInfo, w*64+i)) );
    Vec_IntPush( vRes, Vec_WrdSize(vSimsPi) );
}

Here is the caller graph for this function:

◆ Gia_ManSimInfoInit()

void Gia_ManSimInfoInit ( Gia_ManSim_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 430 of file giaSim.c.

{
    int iPioNum, i;
    Vec_IntForEachEntry( p->vCis2Ids, iPioNum, i )
    {
        if ( iPioNum < Gia_ManPiNum(p->pAig) )
            Gia_ManSimInfoRandom( p, Gia_SimDataCi(p, i) );
        else
            Gia_ManSimInfoZero( p, Gia_SimDataCi(p, i) );
    }
}

Here is the caller graph for this function:

◆ Gia_ManSimInfoTransfer()

void Gia_ManSimInfoTransfer ( Gia_ManSim_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 453 of file giaSim.c.

{
    int iPioNum, i;
    Vec_IntForEachEntry( p->vCis2Ids, iPioNum, i )
    {
        if ( iPioNum < Gia_ManPiNum(p->pAig) )
            Gia_ManSimInfoRandom( p, Gia_SimDataCi(p, i) );
        else
            Gia_ManSimInfoCopy( p, Gia_SimDataCi(p, i), Gia_SimDataCo(p, Gia_ManPoNum(p->pAig)+iPioNum-Gia_ManPiNum(p->pAig)) );
    }
}

Here is the caller graph for this function:

◆ Gia_ManSimPatSim()

Vec_Wrd_t * Gia_ManSimPatSim ( Gia_Man_t * p )

extern

Definition at line 125 of file giaSimBase.c.

{
    Gia_Obj_t * pObj;
    int i, nWords = Vec_WrdSize(pGia->vSimsPi) / Gia_ManCiNum(pGia);
    Vec_Wrd_t * vSims = Vec_WrdStart( Gia_ManObjNum(pGia) * nWords );
    assert( Vec_WrdSize(pGia->vSimsPi) % Gia_ManCiNum(pGia) == 0 );
    Gia_ManSimPatAssignInputs( pGia, nWords, vSims, pGia->vSimsPi );
    Gia_ManForEachAnd( pGia, pObj, i ) 
        Gia_ManSimPatSimAnd( pGia, i, pObj, nWords, vSims );
    Gia_ManForEachCo( pGia, pObj, i )
        Gia_ManSimPatSimPo( pGia, Gia_ObjId(pGia, pObj), pObj, nWords, vSims );
    return vSims;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSimPatSimOut()

Vec_Wrd_t * Gia_ManSimPatSimOut	(	Gia_Man_t *	pGia,
		Vec_Wrd_t *	vSimsPi,
		int	fOuts )

extern

Definition at line 138 of file giaSimBase.c.

{
    Gia_Obj_t * pObj;
    int i, nWords = Vec_WrdSize(vSimsPi) / Gia_ManCiNum(pGia);
    Vec_Wrd_t * vSimsCo = fOuts ? Vec_WrdStart( Gia_ManCoNum(pGia) * nWords ) : NULL;
    Vec_Wrd_t * vSims = Vec_WrdStart( Gia_ManObjNum(pGia) * nWords );
    assert( Vec_WrdSize(vSimsPi) % Gia_ManCiNum(pGia) == 0 );
    Gia_ManSimPatAssignInputs( pGia, nWords, vSims, vSimsPi );
    Gia_ManForEachAnd( pGia, pObj, i ) 
        Gia_ManSimPatSimAnd( pGia, i, pObj, nWords, vSims );
    Gia_ManForEachCo( pGia, pObj, i )
        Gia_ManSimPatSimPo( pGia, Gia_ObjId(pGia, pObj), pObj, nWords, vSims );
    if ( !fOuts )
        return vSims;
    Gia_ManForEachCo( pGia, pObj, i )
        memcpy( Vec_WrdEntryP(vSimsCo, i*nWords), Vec_WrdEntryP(vSims, Gia_ObjId(pGia, pObj)*nWords), sizeof(word)*nWords );
    Vec_WrdFree( vSims );
    return vSimsCo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSimSetDefaultParams()

void Gia_ManSimSetDefaultParams ( Gia_ParSim_t * p )

extern

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

Synopsis [This procedure sets default parameters.]

Description []

SideEffects []

SeeAlso []

Definition at line 165 of file giaSim.c.

{
    memset( p, 0, sizeof(Gia_ParSim_t) );
    // user-controlled parameters
    p->nWords       =   8;    // the number of machine words
    p->nIters       =  32;    // the number of timeframes
    p->RandSeed     =   0;    // the seed to generate random numbers
    p->TimeLimit    =  60;    // time limit in seconds
    p->fCheckMiter  =   0;    // check if miter outputs are non-zero 
    p->fVerbose     =   0;    // enables verbose output
    p->iOutFail     =  -1;    // index of the failed output
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSimSimulate()

int Gia_ManSimSimulate	(	Gia_Man_t *	pAig,
		Gia_ParSim_t *	pPars )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 599 of file giaSim.c.

{
    extern int Gia_ManSimSimulateEquiv( Gia_Man_t * pAig, Gia_ParSim_t * pPars );
    Gia_ManSim_t * p;
    abctime clkTotal = Abc_Clock();
    int i, iOut, iPat, RetValue = 0;
    abctime nTimeToStop = pPars->TimeLimit ? pPars->TimeLimit * CLOCKS_PER_SEC + Abc_Clock(): 0;
    if ( pAig->pReprs && pAig->pNexts )
        return Gia_ManSimSimulateEquiv( pAig, pPars );
    ABC_FREE( pAig->pCexSeq );
    p = Gia_ManSimCreate( pAig, pPars );
    Gia_ManResetRandom( pPars );
    Gia_ManSimInfoInit( p );
    for ( i = 0; i < pPars->nIters; i++ )
    {
        Gia_ManSimulateRound( p );
        if ( pPars->fVerbose )
        {
            Abc_Print( 1, "Frame %4d out of %4d and timeout %3d sec. ", i+1, pPars->nIters, pPars->TimeLimit );
            Abc_Print( 1, "Time = %7.2f sec\r", (1.0*Abc_Clock()-clkTotal)/CLOCKS_PER_SEC );
        }
        if ( pPars->fCheckMiter && Gia_ManCheckPos( p, &iOut, &iPat ) )
        {
            Gia_ManResetRandom( pPars );
            pPars->iOutFail = iOut;
            pAig->pCexSeq = Gia_ManGenerateCounter( pAig, i, iOut, p->nWords, iPat, p->vCis2Ids );
            Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d.  ", iOut, pAig->pName, i );
            if ( !Gia_ManVerifyCex( pAig, pAig->pCexSeq, 0 ) )
            {
//                Abc_Print( 1, "\n" );
                Abc_Print( 1, "\nGenerated counter-example is INVALID.                    " );
//                Abc_Print( 1, "\n" );
            }
            else
            {
//                Abc_Print( 1, "\n" );
//                if ( pPars->fVerbose )
//                Abc_Print( 1, "\nGenerated counter-example is verified correctly.         " );
//                Abc_Print( 1, "\n" );
            }
            RetValue = 1;
            break;
        }
        if ( Abc_Clock() > nTimeToStop )
        {
            i++;
            break;
        }
        if ( i < pPars->nIters - 1 )
            Gia_ManSimInfoTransfer( p );
    }
    Gia_ManSimDelete( p );
    if ( pAig->pCexSeq == NULL )
        Abc_Print( 1, "No bug detected after simulating %d frames with %d words.  ", i, pPars->nWords );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clkTotal );
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSimulateRound()

void Gia_ManSimulateRound ( Gia_ManSim_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 476 of file giaSim.c.

{
    Gia_Obj_t * pObj;
    int i, iCis = 0, iCos = 0;
    assert( p->pAig->nFront > 0 );
    assert( Gia_ManConst0(p->pAig)->Value == 0 );
    Gia_ManSimInfoZero( p, Gia_SimData(p, 0) );
    Gia_ManForEachObj1( p->pAig, pObj, i )
    {
        if ( Gia_ObjIsAndOrConst0(pObj) )
        {
            assert( Gia_ObjValue(pObj) < p->pAig->nFront );
            Gia_ManSimulateNode( p, pObj );
        }
        else if ( Gia_ObjIsCo(pObj) )
        {
            assert( Gia_ObjValue(pObj) == GIA_NONE );
            Gia_ManSimulateCo( p, iCos++, pObj );
        }
        else // if ( Gia_ObjIsCi(pObj) )
        {
            assert( Gia_ObjValue(pObj) < p->pAig->nFront );
            Gia_ManSimulateCi( p, pObj, iCis++ );
        }
    }
    assert( Gia_ManCiNum(p->pAig) == iCis );
    assert( Gia_ManCoNum(p->pAig) == iCos );
}

Here is the caller graph for this function:

◆ Gia_ManSolveProblem()

void Gia_ManSolveProblem	(	Gia_Man_t *	pGia,
		Emb_Par_t *	pPars )

extern

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

Synopsis [Computes dimentions of the graph.]

Description []

SideEffects []

SeeAlso []

Definition at line 1791 of file giaEmbed.c.

{
    Emb_Man_t * p;
    int i;
    abctime clkSetup;
    abctime clk;
//   Gia_ManTestDistance( pGia );
 
    // transform AIG into internal data-structure
clk = Abc_Clock();
    if ( pPars->fCluster )
    {
        p = Emb_ManStart( pGia );
        if ( pPars->fVerbose )
        {
            printf( "Clustered: " );
            Emb_ManPrintStats( p );
        }
    }
    else
        p = Emb_ManStartSimple( pGia );
    p->fVerbose = pPars->fVerbose;
//    Emb_ManPrintFanio( p );
 
    // prepare data-structure
    Gia_ManRandom( 1 );  // reset random numbers for deterministic behavior
    Emb_ManResetTravId( p );
    Emb_ManSetValue( p );
clkSetup = Abc_Clock() - clk;
 
clk = Abc_Clock();
    Emb_ManComputeDimensions( p, pPars->nDims );
if ( pPars->fVerbose )
ABC_PRT( "Setup     ", clkSetup );
if ( pPars->fVerbose )
ABC_PRT( "Dimensions", Abc_Clock() - clk );
 
clk = Abc_Clock();
    Emb_ManComputeCovariance( p, pPars->nDims );
if ( pPars->fVerbose )
ABC_PRT( "Matrix    ", Abc_Clock() - clk );
 
clk = Abc_Clock();
    Emb_ManComputeEigenvectors( p, pPars->nDims, pPars->nSols );
    Emb_ManComputeSolutions( p, pPars->nDims, pPars->nSols );
    Emb_ManDerivePlacement( p, pPars->nSols );
if ( pPars->fVerbose )
ABC_PRT( "Eigenvecs ", Abc_Clock() - clk );
 
    if ( pPars->fRefine )
    {
clk = Abc_Clock();
    Emb_ManPlacementRefine( p, pPars->nIters, pPars->fVerbose );
if ( pPars->fVerbose )
ABC_PRT( "Refinement", Abc_Clock() - clk );
    }
 
    if ( (pPars->fDump || pPars->fDumpLarge) && pPars->nSols == 2 )
    {
clk = Abc_Clock();
        Emb_ManDumpGnuplot( p, pGia->pName, pPars->fDumpLarge, pPars->fShowImage );
if ( pPars->fVerbose )
ABC_PRT( "Image dump", Abc_Clock() - clk );
    }
 
    // transfer placement
    if ( Gia_ManObjNum(pGia) == p->nObjs )
    {
        // assuming normalized ordering of the AIG
        pGia->pPlacement = ABC_CALLOC( Gia_Plc_t, p->nObjs );
        for ( i = 0; i < p->nObjs; i++ ) 
        {
            pGia->pPlacement[i].xCoord = p->pPlacement[2*i+0];
            pGia->pPlacement[i].yCoord = p->pPlacement[2*i+1];
        }
    }
    Emb_ManStop( p );
}

Here is the call graph for this function:

◆ Gia_ManSpecReduce()

Gia_Man_t * Gia_ManSpecReduce	(	Gia_Man_t *	p,
		int	fDualOut,
		int	fSynthesis,
		int	fSpeculate,
		int	fSkipSome,
		int	fVerbose )

extern

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1253 of file giaEquiv.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    Vec_Int_t * vXorLits;
    int i, iLitNew;
    Vec_Int_t * vTrace = NULL, * vGuide = NULL;
    if ( !p->pReprs )
    {
        Abc_Print( 1, "Gia_ManSpecReduce(): Equivalence classes are not available.\n" );
        return NULL;
    }
    if ( fDualOut && (Gia_ManPoNum(p) & 1) )
    {
        Abc_Print( 1, "Gia_ManSpecReduce(): Dual-output miter should have even number of POs.\n" );
        return NULL;
    }
    if ( fSkipSome )
    {
        vGuide = Vec_IntAlloc( 100 );
        pTemp  = Gia_ManSpecReduceTrace( p, vGuide, NULL );
        Gia_ManStop( pTemp );
        assert( Vec_IntSize(vGuide) == Gia_ManEquivCountLitsAll(p) );
        vTrace = Vec_IntAlloc( 100 );
    }
    vXorLits = Vec_IntAlloc( 1000 );
    Gia_ManSetPhase( p );
    Gia_ManFillValue( p );
    if ( fDualOut )
        Gia_ManEquivSetColors( p, fVerbose );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    Gia_ManForEachRo( p, pObj, i )
        Gia_ManSpecBuild( pNew, p, pObj, vXorLits, fDualOut, fSpeculate, vTrace, vGuide, NULL );
    Gia_ManForEachCo( p, pObj, i )
        Gia_ManSpecReduce_rec( pNew, p, Gia_ObjFanin0(pObj), vXorLits, fDualOut, fSpeculate, vTrace, vGuide, NULL );
    if ( !fSynthesis )
    {
        Gia_ManForEachPo( p, pObj, i )
            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    }
    Vec_IntForEachEntry( vXorLits, iLitNew, i )
        Gia_ManAppendCo( pNew, iLitNew );
    if ( Vec_IntSize(vXorLits) == 0 )
    {
        Abc_Print( 1, "Speculatively reduced model has no primary outputs.\n" );
        Gia_ManAppendCo( pNew, 0 );
    }
    Gia_ManForEachRi( p, pObj, i )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Vec_IntFree( vXorLits );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
 
    // update using trace
    if ( fSkipSome )
    {
        // count the number of non-zero entries
        int iLit, nAddPos = 0;
        Vec_IntForEachEntry( vGuide, iLit, i )
            if ( iLit )
                nAddPos++;
        if ( nAddPos )
            assert( Gia_ManPoNum(pNew) == Gia_ManPoNum(p) + nAddPos );
    }
    Vec_IntFreeP( &vTrace );
    Vec_IntFreeP( &vGuide );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSpecReduceInit()

Gia_Man_t * Gia_ManSpecReduceInit	(	Gia_Man_t *	p,
		Abc_Cex_t *	pInit,
		int	nFrames,
		int	fDualOut )

extern

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

Synopsis [Creates initialized SRM with the given number of frames.]

Description []

SideEffects []

SeeAlso []

Definition at line 1390 of file giaEquiv.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pObjRi, * pObjRo;
    Vec_Int_t * vXorLits;
    int f, i, iLitNew;
    if ( !p->pReprs )
    {
        Abc_Print( 1, "Gia_ManSpecReduceInit(): Equivalence classes are not available.\n" );
        return NULL;
    }
    if ( Gia_ManRegNum(p) == 0 )
    {
        Abc_Print( 1, "Gia_ManSpecReduceInit(): Circuit is not sequential.\n" );
        return NULL;
    }
    if ( Gia_ManRegNum(p) != pInit->nRegs )
    {
        Abc_Print( 1, "Gia_ManSpecReduceInit(): Mismatch in the number of registers.\n" );
        return NULL;
    }
    if ( fDualOut && (Gia_ManPoNum(p) & 1) )
    {
        Abc_Print( 1, "Gia_ManSpecReduceInit(): Dual-output miter should have even number of POs.\n" );
        return NULL;
    }
 
/*
    if ( !Gia_ManCheckTopoOrder( p ) )
    {
        Abc_Print( 1, "Gia_ManSpecReduceInit(): AIG is not in a correct topological order.\n" );
        return NULL;
    }
*/
    assert( pInit->nRegs == Gia_ManRegNum(p) && pInit->nPis == 0 );
    Vec_IntFill( &p->vCopies, nFrames * Gia_ManObjNum(p), -1 );
    vXorLits = Vec_IntAlloc( 1000 );
    Gia_ManSetPhase( p );
    if ( fDualOut )
        Gia_ManEquivSetColors( p, 0 );
    pNew = Gia_ManStart( nFrames * Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachRo( p, pObj, i )
        Gia_ObjSetCopyF( p, 0, pObj, Abc_InfoHasBit(pInit->pData, i) );
    for ( f = 0; f < nFrames; f++ )
    {
        Gia_ObjSetCopyF( p, f, Gia_ManConst0(p), 0 );
        Gia_ManForEachPi( p, pObj, i )
            Gia_ObjSetCopyF( p, f, pObj, Gia_ManAppendCi(pNew) );
        Gia_ManForEachRo( p, pObj, i )
            Gia_ManSpecBuildInit( pNew, p, pObj, vXorLits, f, fDualOut );
        Gia_ManForEachCo( p, pObj, i )
        {
            Gia_ManSpecReduceInit_rec( pNew, p, Gia_ObjFanin0(pObj), vXorLits, f, fDualOut );
            Gia_ObjSetCopyF( p, f, pObj, Gia_ObjFanin0CopyF(p, f, pObj) );
        }
        if ( f == nFrames - 1 )
            break;
        Gia_ManForEachRiRo( p, pObjRi, pObjRo, i )
            Gia_ObjSetCopyF( p, f+1, pObjRo, Gia_ObjCopyF(p, f, pObjRi) );
    }
    Vec_IntForEachEntry( vXorLits, iLitNew, i )
        Gia_ManAppendCo( pNew, iLitNew );
    if ( Vec_IntSize(vXorLits) == 0 )
    {
//        Abc_Print( 1, "Speculatively reduced model has no primary outputs.\n" );
        Gia_ManAppendCo( pNew, 0 );
    }
    Vec_IntErase( &p->vCopies );
    Vec_IntFree( vXorLits );
    Gia_ManHashStop( pNew );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSpecReduceInitFrames()

Gia_Man_t * Gia_ManSpecReduceInitFrames	(	Gia_Man_t *	p,
		Abc_Cex_t *	pInit,
		int	nFramesMax,
		int *	pnFrames,
		int	fDualOut,
		int	nMinOutputs )

extern

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

Synopsis [Creates initialized SRM with the given number of frames.]

Description [Uses as many frames as needed to create the number of output not less than the number of equivalence literals.]

SideEffects []

SeeAlso []

Definition at line 1480 of file giaEquiv.c.

{
    Gia_Man_t * pFrames;
    int f, nLits;
    nLits = Gia_ManEquivCountLits( p );
    for ( f = 1; ; f++ )
    {
        pFrames = Gia_ManSpecReduceInit( p, pInit, f, fDualOut );
        if ( (nMinOutputs == 0 && Gia_ManPoNum(pFrames) >= nLits/2+1) ||
             (nMinOutputs != 0 && Gia_ManPoNum(pFrames) >= nMinOutputs) )
            break;
        if ( f == nFramesMax )
            break;
        if ( Gia_ManAndNum(pFrames) > 500000 )
        {
            Gia_ManStop( pFrames );
            return NULL;
        }
        Gia_ManStop( pFrames );
        pFrames = NULL;
    }
    if ( f == nFramesMax )
        Abc_Print( 1, "Stopped unrolling after %d frames.\n", nFramesMax );
    if ( pnFrames )
        *pnFrames = f;
    return pFrames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSpeedup()

Gia_Man_t * Gia_ManSpeedup	(	Gia_Man_t *	p,
		int	Percentage,
		int	Degree,
		int	fVerbose,
		int	fVeryVerbose )

extern

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

Synopsis [Adds choices to speed up the network by the given percentage.]

Description []

SideEffects []

SeeAlso []

Definition at line 629 of file giaSpeedup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Vec_Int_t * vTimeCries, * vTimeFanins;
    int iObj, iFanin, iFanin2, nNodesNew;
    float tDelta, tArrival;
    int i, k, k2, Counter, CounterRes, nTimeCris;
    int fUseLutLib = (p->pLutLib != NULL);
    void * pTempTim = NULL;
    unsigned * puTCEdges;
    assert( Gia_ManHasMapping(p) );
    if ( !fUseLutLib && p->pManTime )
    {
        pTempTim = p->pManTime;
        p->pManTime = Tim_ManDup( (Tim_Man_t *)pTempTim, 1 );
    }
    // perform delay trace
    tArrival = Gia_ManDelayTraceLut( p );
    tDelta = fUseLutLib ? tArrival*Percentage/100.0 : 1.0;
    if ( fVerbose )
    {
        printf( "Max delay = %.2f. Delta = %.2f. ", tArrival, tDelta );
        printf( "Using %s model. ", fUseLutLib ? "LUT library" : "unit-delay" );
        if ( fUseLutLib )
            printf( "Percentage = %d. ", Percentage );
        printf( "\n" );
    }
    // mark the timing critical nodes and edges
    puTCEdges = ABC_CALLOC( unsigned, Gia_ManObjNum(p) );
    Gia_ManForEachLut( p, iObj )
    {
        if ( Gia_ObjTimeSlack(p, iObj) >= tDelta )
            continue;
        puTCEdges[iObj] = Gia_LutDelayTraceTCEdges( p, iObj, tDelta );
    }
    if ( fVerbose )
    {
        Counter = CounterRes = 0;
        Gia_ManForEachLut( p, iObj )
        {
            Gia_LutForEachFanin( p, iObj, iFanin, k )
                if ( !Gia_ObjIsCi(Gia_ManObj(p, iFanin)) && Gia_ObjTimeSlack(p, iFanin) < tDelta )
                    Counter++;
            CounterRes += Gia_WordCountOnes( puTCEdges[iObj] );
        }
        printf( "Edges: Total = %7d. 0-slack = %7d. Critical = %7d. Ratio = %4.2f\n", 
            Gia_ManLutFaninCount(p), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
    }
 
    // start the resulting network
    pNew = Gia_ManDup( p );
    Gia_ManHashStart( pNew );
    nNodesNew = 1000 + 3 * Gia_ManObjNum(pNew);
    pNew->pNexts = ABC_CALLOC( int, nNodesNew );
    pNew->pReprs = ABC_CALLOC( Gia_Rpr_t, nNodesNew );
    for ( i = 0; i < nNodesNew; i++ )
        Gia_ObjSetRepr( pNew, i, GIA_VOID );
 
    // collect nodes to be used for resynthesis
    Counter = CounterRes = 0;
    vTimeCries = Vec_IntAlloc( 16 );
    vTimeFanins = Vec_IntAlloc( 16 );
    Gia_ManForEachLut( p, iObj )
    {
        if ( Gia_ObjTimeSlack(p, iObj) >= tDelta )
            continue;
        // count the number of non-PI timing-critical nodes
        nTimeCris = 0;
        Gia_LutForEachFanin( p, iObj, iFanin, k )
            if ( !Gia_ObjIsCi(Gia_ManObj(p, iFanin)) && (puTCEdges[iObj] & (1<<k)) )
                nTimeCris++;
        if ( !fVeryVerbose && nTimeCris == 0 )
            continue;
        Counter++;
        // count the total number of timing critical second-generation nodes
        Vec_IntClear( vTimeCries );
        if ( nTimeCris )
        {
            Gia_LutForEachFanin( p, iObj, iFanin, k )
                if ( !Gia_ObjIsCi(Gia_ManObj(p, iFanin)) && (puTCEdges[iObj] & (1<<k)) )
                    Gia_LutForEachFanin( p, iFanin, iFanin2, k2 )
                        if ( puTCEdges[iFanin] & (1<<k2) )
                            Vec_IntPushUnique( vTimeCries, iFanin2 );
        }
//        if ( !fVeryVerbose && (Vec_IntSize(vTimeCries) == 0 || Vec_IntSize(vTimeCries) > Degree) )
        if ( (Vec_IntSize(vTimeCries) == 0 || Vec_IntSize(vTimeCries) > Degree) )
            continue;
        CounterRes++;
        // collect second generation nodes
        Vec_IntClear( vTimeFanins );
        Gia_LutForEachFanin( p, iObj, iFanin, k )
        {
            if ( Gia_ObjIsCi(Gia_ManObj(p, iFanin)) )
                Vec_IntPushUnique( vTimeFanins, iFanin );
            else
                Gia_LutForEachFanin( p, iFanin, iFanin2, k2 )
                    Vec_IntPushUnique( vTimeFanins, iFanin2 );                    
        }
        // print the results
        if ( fVeryVerbose )
        {
        printf( "%5d Node %5d : %d %2d %2d  ", Counter, iObj, 
            nTimeCris, Vec_IntSize(vTimeCries), Vec_IntSize(vTimeFanins) );
        Gia_LutForEachFanin( p, iObj, iFanin, k )
            printf( "%d(%.2f)%s ", iFanin, Gia_ObjTimeSlack(p, iFanin), (puTCEdges[iObj] & (1<<k))? "*":"" );
        printf( "\n" );
        }
        // add the node to choices
        if ( Vec_IntSize(vTimeCries) == 0 || Vec_IntSize(vTimeCries) > Degree )
            continue;
        // order the fanins in the increasing order of criticalily
        if ( Vec_IntSize(vTimeCries) > 1 )
        {
            iFanin = Vec_IntEntry( vTimeCries, 0 );
            iFanin2 = Vec_IntEntry( vTimeCries, 1 );
            if ( Gia_ObjTimeSlack(p, iFanin) < Gia_ObjTimeSlack(p, iFanin2) )
            {
                Vec_IntWriteEntry( vTimeCries, 0, iFanin2 );
                Vec_IntWriteEntry( vTimeCries, 1, iFanin );
            }
        }
        if ( Vec_IntSize(vTimeCries) > 2 )
        {
            iFanin = Vec_IntEntry( vTimeCries, 1 );
            iFanin2 = Vec_IntEntry( vTimeCries, 2 );
            if ( Gia_ObjTimeSlack(p, iFanin) < Gia_ObjTimeSlack(p, iFanin2) )
            {
                Vec_IntWriteEntry( vTimeCries, 1, iFanin2 );
                Vec_IntWriteEntry( vTimeCries, 2, iFanin );
            }
            iFanin = Vec_IntEntry( vTimeCries, 0 );
            iFanin2 = Vec_IntEntry( vTimeCries, 1 );
            if ( Gia_ObjTimeSlack(p, iFanin) < Gia_ObjTimeSlack(p, iFanin2) )
            {
                Vec_IntWriteEntry( vTimeCries, 0, iFanin2 );
                Vec_IntWriteEntry( vTimeCries, 1, iFanin );
            }
        }
        // add choice
        Gia_ManSpeedupObj( pNew, p, Gia_ManObj(p,iObj), vTimeFanins, vTimeCries );
        // quit if the number of nodes is large
        if ( Gia_ManObjNum(pNew) > nNodesNew - 100 )
        {
            printf( "Speedup stopped adding choices because there was too many to add.\n" );
            break;
        }
    }
    Gia_ManTimeStop( p );
    Vec_IntFree( vTimeCries );
    Vec_IntFree( vTimeFanins );
    ABC_FREE( puTCEdges );
    if ( fVerbose )
        printf( "Nodes: Total = %7d. 0-slack = %7d. Workable = %7d. Ratio = %4.2f\n", 
        Gia_ManLutNum(p), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 ); 
    if ( pTempTim )
    {
        Tim_ManStop( (Tim_Man_t *)p->pManTime );
        p->pManTime = pTempTim;
    }
    // derive AIG with choices
//Gia_ManPrintStats( pNew, 0 );
    pTemp = Gia_ManEquivToChoices( pNew, 1 );
    Gia_ManStop( pNew );
//Gia_ManPrintStats( pTemp, 0 );
//    pNew = Gia_ManDupOrderDfsChoices( pTemp );
//    Gia_ManStop( pTemp );
//Gia_ManPrintStats( pNew, 0 );
//    return pNew;
    return pTemp;
}

Here is the call graph for this function:

◆ Gia_ManStart()

Gia_Man_t * Gia_ManStart ( int nObjsMax )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 57 of file giaMan.c.

{
    Gia_Man_t * p;
    assert( nObjsMax > 0 );
    p = ABC_CALLOC( Gia_Man_t, 1 );
    p->nObjsAlloc = nObjsMax;
    p->pObjs = ABC_CALLOC( Gia_Obj_t, nObjsMax );
    p->pObjs->iDiff0 = p->pObjs->iDiff1 = GIA_NONE;
    p->nObjs = 1;
    p->vCis  = Vec_IntAlloc( nObjsMax / 20 );
    p->vCos  = Vec_IntAlloc( nObjsMax / 20 );
    return p;
}

◆ Gia_ManStaticFanoutStart()

void Gia_ManStaticFanoutStart ( Gia_Man_t * p )

extern

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

Synopsis [Allocates static fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 238 of file giaFanout.c.

{
    Vec_Int_t * vCounts;
    int * pRefsOld;
    Gia_Obj_t * pObj, * pFanin;
    int i, iFanout;
    assert( p->vFanoutNums == NULL );
    assert( p->vFanout == NULL );
    // recompute reference counters
    pRefsOld = p->pRefs; p->pRefs = NULL;
    Gia_ManCreateRefs(p);
    p->vFanoutNums = Vec_IntAllocArray( p->pRefs, Gia_ManObjNum(p) );
    p->pRefs = pRefsOld;
    // start the fanout maps
    p->vFanout = Gia_ManStartFanoutMap( p, p->vFanoutNums );
    // incrementally add fanouts
    vCounts = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_ManForEachObj( p, pObj, i )
    {
        if ( Gia_ObjIsAnd(pObj) || Gia_ObjIsCo(pObj) )
        {
            pFanin = Gia_ObjFanin0(pObj);
            iFanout = Vec_IntEntry( vCounts, Gia_ObjId(p, pFanin) );
            Gia_ObjSetFanout( p, pFanin, iFanout, pObj );
            Vec_IntAddToEntry( vCounts, Gia_ObjId(p, pFanin), 1 );
        }
        if ( Gia_ObjIsAnd(pObj) && !Gia_ObjIsBuf(pObj) )
        {
            pFanin = Gia_ObjFanin1(pObj);
            iFanout = Vec_IntEntry( vCounts, Gia_ObjId(p, pFanin) );
            Gia_ObjSetFanout( p, pFanin, iFanout, pObj );
            Vec_IntAddToEntry( vCounts, Gia_ObjId(p, pFanin), 1 );
        }
        if ( Gia_ObjIsMux(p, pObj) )
        {
 
            pFanin = Gia_ObjFanin2(p, pObj);
            iFanout = Vec_IntEntry( vCounts, Gia_ObjId(p, pFanin) );
            Gia_ObjSetFanout( p, pFanin, iFanout, pObj );
            Vec_IntAddToEntry( vCounts, Gia_ObjId(p, pFanin), 1 );
        }
    }
    // double-check the current number of fanouts added
    Gia_ManForEachObj( p, pObj, i )
        assert( Vec_IntEntry(vCounts, i) == Gia_ObjFanoutNum(p, pObj) );
    Vec_IntFree( vCounts );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManStaticFanoutStop()

void Gia_ManStaticFanoutStop ( Gia_Man_t * p )

extern

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

Synopsis [Deallocates static fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 393 of file giaFanout.c.

{
    Vec_IntFreeP( &p->vFanoutNums );
    Vec_IntFreeP( &p->vFanout );
}

Here is the caller graph for this function:

◆ Gia_ManStaticMappingFanoutStart()

void Gia_ManStaticMappingFanoutStart	(	Gia_Man_t *	p,
		Vec_Int_t **	pvIndex )

extern

Definition at line 335 of file giaFanout.c.

{
    Vec_Int_t * vCounts;
    int * pRefsOld;
    Gia_Obj_t * pObj, * pFanin;
    int i, k, iFan, iFanout, Index;
    assert( p->vFanoutNums == NULL );
    assert( p->vFanout == NULL );
    // recompute reference counters
    pRefsOld = p->pLutRefs; p->pLutRefs = NULL;
    Gia_ManSetLutRefs(p);
    p->vFanoutNums = Vec_IntAllocArray( p->pLutRefs, Gia_ManObjNum(p) );
    p->pLutRefs = pRefsOld;
    // start the fanout maps
    p->vFanout = Gia_ManStartMappingFanoutMap( p, p->vFanoutNums );
    if ( pvIndex )
        *pvIndex = Vec_IntStart( Vec_IntSize(p->vFanout) );
    // incrementally add fanouts
    vCounts = Vec_IntStart( Gia_ManObjNum(p) );
    Gia_ManForEachLut( p, i )
    {
        Gia_ObjCheckDupMappingFanins( p, i );
        pObj = Gia_ManObj( p, i );
        Gia_LutForEachFaninIndex( p, i, iFan, k, Index )
        {
            pFanin = Gia_ManObj( p, iFan );
            iFanout = Vec_IntEntry( vCounts, iFan );
            Gia_ObjSetFanout( p, pFanin, iFanout, pObj );
            Vec_IntAddToEntry( vCounts, iFan, 1 );
            if ( pvIndex )
                Vec_IntWriteEntry( *pvIndex, Vec_IntEntry(p->vFanout, iFan) + iFanout, Index );
        }
    }
    Gia_ManForEachCo( p, pObj, i )
    {
        iFan = Gia_ObjFaninId0p(p, pObj);
        pFanin = Gia_ManObj( p, iFan );
        iFanout = Vec_IntEntry( vCounts, iFan );
        Gia_ObjSetFanout( p, pFanin, iFanout, pObj );
        Vec_IntAddToEntry( vCounts, iFan, 1 );
    }
    // double-check the current number of fanouts added
    Gia_ManForEachObj( p, pObj, i )
        assert( Vec_IntEntry(vCounts, i) == Gia_ObjFanoutNum(p, pObj) );
    Vec_IntFree( vCounts );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManStgPrint()

void Gia_ManStgPrint	(	FILE *	pFile,
		Vec_Int_t *	vLines,
		int	nIns,
		int	nOuts,
		int	nStates )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 407 of file giaStg.c.

{
    int i, nDigits = Abc_Base10Log( nStates );
    assert( Vec_IntSize(vLines) % 4 == 0 );
    for ( i = 0; i < Vec_IntSize(vLines); i += 4 )
    {
        int iMint = Vec_IntEntry(vLines, i  );
        int iCur  = Vec_IntEntry(vLines, i+1) - 1;
        int iNext = Vec_IntEntry(vLines, i+2) - 1;
        int iOut  = Vec_IntEntry(vLines, i+3);
        assert( iMint >= 0 && iMint < (1<<nIns)  );
        assert( iCur  >= 0 && iCur  < nStates    );
        assert( iNext >= 0 && iNext < nStates    );
        assert( iOut  >= 0 && iOut  < (1<<nOuts) );
        Extra_PrintBinary( pFile, (unsigned *)Vec_IntEntryP(vLines, i),  nIns );
        fprintf( pFile, " %*d",  nDigits,     Vec_IntEntry(vLines,  i+1) );
        fprintf( pFile, " %*d ", nDigits,     Vec_IntEntry(vLines,  i+2) );
        Extra_PrintBinary( pFile, (unsigned *)Vec_IntEntryP(vLines, i+3), nOuts );
        fprintf( pFile, "\n" );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManStgRead()

Gia_Man_t * Gia_ManStgRead	(	char *	pFileName,
		int	kHot,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 508 of file giaStg.c.

{
    Gia_Man_t * p;
    Vec_Int_t * vLines;
    int nIns, nOuts, nStates;
    vLines = Gia_ManStgReadLines( pFileName, &nIns, &nOuts, &nStates );
    if ( vLines == NULL )
        return NULL;
//    p = Gia_ManStgOneHot( vLines, nIns, nOuts, nStates );
    p = Gia_ManStgKHot( vLines, nIns, nOuts, nStates, kHot, fVerbose );
    Vec_IntFree( vLines );
    return p;
}

Here is the call graph for this function:

◆ Gia_ManStop()

void Gia_ManStop ( Gia_Man_t * p )

extern

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

Synopsis [Deletes AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 82 of file giaMan.c.

{
    if ( p->vSeqModelVec )
        Vec_PtrFreeFree( p->vSeqModelVec );
    Gia_ManStaticFanoutStop( p );
    Tim_ManStopP( (Tim_Man_t **)&p->pManTime );
    assert( p->pManTime == NULL );
    Vec_PtrFreeFree( p->vNamesIn );
    Vec_PtrFreeFree( p->vNamesOut );
    Vec_PtrFreeFree( p->vNamesNode );
    Vec_IntFreeP( &p->vSwitching );
    Vec_IntFreeP( &p->vSuper );
    Vec_IntFreeP( &p->vStore );
    Vec_IntFreeP( &p->vClassNew );
    Vec_IntFreeP( &p->vClassOld );
    Vec_IntFreeP( &p->vPats );
    Vec_BitFreeP( &p->vPolars );
    Vec_WrdFreeP( &p->vSims );
    Vec_WrdFreeP( &p->vSimsT );
    Vec_WrdFreeP( &p->vSimsPi );
    Vec_WrdFreeP( &p->vSimsPo );
    Vec_IntFreeP( &p->vTimeStamps );
    Vec_FltFreeP( &p->vTiming );
    Vec_VecFreeP( &p->vClockDoms );
    Vec_IntFreeP( &p->vCofVars );
    Vec_IntFreeP( &p->vIdsOrig );
    Vec_IntFreeP( &p->vIdsEquiv );
    Vec_IntFreeP( &p->vLutConfigs );
    Vec_IntFreeP( &p->vEdgeDelay );
    Vec_IntFreeP( &p->vEdgeDelayR );
    Vec_IntFreeP( &p->vEdge1 );
    Vec_IntFreeP( &p->vEdge2 );
    Vec_IntFreeP( &p->vUserPiIds );
    Vec_IntFreeP( &p->vUserPoIds );
    Vec_IntFreeP( &p->vUserFfIds );
    Vec_IntFreeP( &p->vFlopClasses );
    Vec_IntFreeP( &p->vGateClasses );
    Vec_IntFreeP( &p->vObjClasses );
    Vec_IntFreeP( &p->vInitClasses );
    Vec_IntFreeP( &p->vRegClasses );
    Vec_IntFreeP( &p->vRegInits );
    Vec_IntFreeP( &p->vDoms );
    Vec_IntFreeP( &p->vBarBufs );
    Vec_IntFreeP( &p->vXors );
    Vec_IntFreeP( &p->vLevels );
    Vec_IntFreeP( &p->vTruths );
    Vec_IntErase( &p->vCopies );
    Vec_IntErase( &p->vCopies2 );
    Vec_IntFreeP( &p->vVar2Obj );
    Vec_IntErase( &p->vCopiesTwo );
    Vec_IntErase( &p->vSuppVars );
    Vec_IntErase( &p->vVarMap );
    Vec_WrdFreeP( &p->vSuppWords );
    Vec_IntFreeP( &p->vTtNums );
    Vec_IntFreeP( &p->vTtNodes );
    Vec_WrdFreeP( &p->vTtMemory );
    Vec_PtrFreeP( &p->vTtInputs );
    Vec_IntFreeP( &p->vMapping );
    Vec_WecFreeP( &p->vMapping2 );
    Vec_WecFreeP( &p->vFanouts2 );
    Vec_IntFreeP( &p->vCellMapping );
    Vec_IntFreeP( &p->vPacking );
    Vec_IntFreeP( &p->vConfigs );
    ABC_FREE( p->pCellStr );
    Vec_FltFreeP( &p->vInArrs );
    Vec_FltFreeP( &p->vOutReqs );
    Vec_IntFreeP( &p->vCiArrs );
    Vec_IntFreeP( &p->vCoReqs );
    Vec_IntFreeP( &p->vCoArrs );
    Vec_IntFreeP( &p->vCoAttrs );
    Vec_IntFreeP( &p->vWeights );
    Gia_ManStopP( &p->pAigExtra );
    Vec_IntFree( p->vCis );
    Vec_IntFree( p->vCos );
    Vec_IntErase( &p->vHash );
    Vec_IntErase( &p->vHTable );
    Vec_IntErase( &p->vRefs );
    Vec_StrFreeP( &p->vStopsF );
    Vec_StrFreeP( &p->vStopsB );    
    ABC_FREE( p->pData2 );
    ABC_FREE( p->pTravIds );
    ABC_FREE( p->pPlacement );
    ABC_FREE( p->pSwitching );
    ABC_FREE( p->pCexSeq );
    ABC_FREE( p->pCexComb );
    ABC_FREE( p->pIso );
//    ABC_FREE( p->pMapping );
    ABC_FREE( p->pFanData );
    ABC_FREE( p->pReprsOld );
    ABC_FREE( p->pReprs );
    ABC_FREE( p->pNexts );
    ABC_FREE( p->pSibls );
    ABC_FREE( p->pRefs );
    ABC_FREE( p->pLutRefs );
    ABC_FREE( p->pMuxes );
    ABC_FREE( p->pObjs );
    ABC_FREE( p->pSpec );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

Here is the call graph for this function:

◆ Gia_ManStopP()

void Gia_ManStopP ( Gia_Man_t ** p )

extern

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

Synopsis [Stops the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 224 of file giaMan.c.

{
    if ( *p == NULL )
        return;
    Gia_ManStop( *p );
    *p = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSupportAnd()

int Gia_ManSupportAnd	(	Gia_ManMin_t *	p,
		int	iLit0,
		int	iLit1 )

extern

Definition at line 280 of file giaSupp.c.

280{ return 0; }

Here is the caller graph for this function:

◆ Gia_ManSuppSize()

int Gia_ManSuppSize	(	Gia_Man_t *	p,
		int *	pNodes,
		int	nNodes )

extern

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 324 of file giaDfs.c.

{
    Gia_Obj_t * pObj;
    int i, Counter = 0; 
    Gia_ManIncrementTravId( p );
    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
    for ( i = 0; i < nNodes; i++ )
    {
        pObj = Gia_ManObj( p, pNodes[i] );
        if ( Gia_ObjIsCo(pObj) )
            Counter += Gia_ManSuppSize_rec( p, Gia_ObjFanin0(pObj) );
        else
            Counter += Gia_ManSuppSize_rec( p, pObj );
    }
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManSuppStart()

Gia_ManMin_t * Gia_ManSuppStart ( Gia_Man_t * pGia )

extern

DECLARATIONS ///.

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

FileName [giaSupp.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Support minimization for AIGs.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 279 of file giaSupp.c.

279{ return NULL; }

Here is the caller graph for this function:

◆ Gia_ManSuppStop()

void Gia_ManSuppStop ( Gia_ManMin_t * p )

extern

Definition at line 281 of file giaSupp.c.

281{}

Here is the caller graph for this function:

◆ Gia_ManSwapPos()

void Gia_ManSwapPos	(	Gia_Man_t *	p,
		int	i )

extern

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_ManSweepWithBoxes()

Gia_Man_t * Gia_ManSweepWithBoxes	(	Gia_Man_t *	p,
		void *	pParsC,
		void *	pParsS,
		int	fConst,
		int	fEquiv,
		int	fVerbose,
		int	fVerbEquivs )

extern

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

Synopsis [Reduces root model with scorr.]

Description []

SideEffects []

SeeAlso []

Definition at line 739 of file giaSweep.c.

{ 
    Gia_Man_t * pClp, * pNew, * pTemp;
    int * pReprs, pFlopTypes[3] = {0};
    int nFlopsNew, nFlops;
    assert( Gia_ManRegNum(p) == 0 );
    assert( p->pAigExtra != NULL );
    // consider seq synthesis with multiple clock domains
    if ( pParsC == NULL && Gia_ManClockDomainNum(p) > 1 )
        return Gia_ManSweepWithBoxesAndDomains( p, pParsS, fConst, fEquiv, fVerbose, fVerbEquivs );
    // order AIG objects
    pNew = Gia_ManDupUnnormalize( p );
    if ( pNew == NULL )
        return NULL;
    Gia_ManTransferTiming( pNew, p );
    nFlops = Vec_IntCountEntry(pNew->vRegClasses, 1);
    // find global equivalences
    pClp = Gia_ManDupCollapse( pNew, pNew->pAigExtra, NULL, pParsC ? 0 : 1 );
    //Gia_DumpAiger( pClp, p->pSpec, 1, 1 );
    // compute equivalences
    if ( pParsC )
        Gia_ManFraigSweepPerform( pClp, pParsC );
    else if ( pParsS )
        Cec_ManLSCorrespondenceClasses( pClp, (Cec_ParCor_t *)pParsS );
    else 
        Gia_ManSeqCleanupClasses( pClp, fConst, fEquiv, fVerbose );
    // transfer equivalences
    pReprs = Gia_ManFraigSelectReprs( pNew, pClp, fVerbose, pFlopTypes );
    Gia_ManStop( pClp );
    // reduce AIG
    Gia_ManTransferTiming( p, pNew );
    pNew = Gia_ManFraigReduceGia( pTemp = pNew, pReprs );
    Gia_ManTransferTiming( pNew, p );
    Gia_ManStop( pTemp );
    ABC_FREE( pReprs );
    // derive new AIG
    pNew = Gia_ManDupWithBoxes( pTemp = pNew, pParsC ? 0 : 1 );
    Gia_ManStop( pTemp );
    // report
    nFlopsNew = Vec_IntCountEntry(pNew->vRegClasses, 1);
    pFlopTypes[2] = nFlops - nFlopsNew - (pFlopTypes[0] + pFlopTypes[1]);
    if ( fVerbEquivs )
    {
        printf( "Domain %2d : %5d -> %5d :  ", 1, nFlops, nFlopsNew );
        printf( "EqConst =%4d.  EqFlop =%4d.  Dangling =%4d.  Unused =%4d.\n", 
            pFlopTypes[0], pFlopTypes[1], Abc_MaxInt(0, pFlopTypes[2]), Abc_MaxInt(0, -pFlopTypes[2]) );
    }
    // normalize the result
    pNew = Gia_ManDupNormalize( pTemp = pNew, 0 );
    Gia_ManTransferTiming( pNew, pTemp );
    Gia_ManStop( pTemp );
    // check integrity
    //Gia_ManCheckIntegrityWithBoxes( pNew );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManTestDistance()

void Gia_ManTestDistance ( Gia_Man_t * pGia )

extern

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

Synopsis [Returns sorted array of node handles with largest fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 904 of file giaEmbed.c.

{
    Emb_Man_t * p;
    abctime clk = Abc_Clock();
    p = Emb_ManStart( pGia );
//    Emb_ManPrintFanio( p );
    Emb_ManPrintStats( p );
ABC_PRT( "Time", Abc_Clock() - clk );
    Gia_ManTestDistanceInternal( p );
    Emb_ManStop( p );
}

Here is the call graph for this function:

◆ Gia_ManTransductionBdd()

Gia_Man_t * Gia_ManTransductionBdd	(	Gia_Man_t *	pGia,
		int	nType,
		int	fMspf,
		int	nRandom,
		int	nSortType,
		int	nPiShuffle,
		int	nParameter,
		int	fLevel,
		Gia_Man_t *	pExdc,
		int	fNewLine,
		int	nVerbose )

extern

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

FileName [giaTransduction.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Implementation of transduction method.]

Author [Yukio Miyasaka]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - May 2023.]

Revision [

Id: giaTransduction.c,v 1.00 2023/05/10 00:00:00 Exp

]

Definition at line 35 of file giaTransduction.cpp.

                                                                                                                                                                                               {
  if(nRandom) {
    srand(nRandom);
    nSortType = rand() % 4;
    nPiShuffle = rand();
    nParameter = rand() % 16;
  }
  NewBdd::Param p;
  Transduction::Transduction<NewBdd::Man, NewBdd::Param, NewBdd::lit, 0xffffffff> t(pGia, nVerbose, fNewLine, nSortType, nPiShuffle, fLevel, pExdc, p);
  int count = t.CountWires();
  switch(nType) {
  case 0:
    count -= fMspf? t.Mspf(): t.Cspf();
    break;
  case 1:
    count -= t.Resub(fMspf);
    break;
  case 2:
    count -= t.ResubMono(fMspf);
    break;
  case 3:
    count -= t.ResubShared(fMspf);
    break;
  case 4:
    count -= t.RepeatResub(false, fMspf);
    break;
  case 5:
    count -= t.RepeatResub(true, fMspf);
    break;
  case 6: {
    bool fInner = (nParameter / 4) % 2;
    count -= t.RepeatInner(fMspf, fInner);
    break;
  }
  case 7: {
    bool fInner = (nParameter / 4) % 2;
    bool fOuter = (nParameter / 8) % 2;
    count -= t.RepeatOuter(fMspf, fInner, fOuter);
    break;
  }
  case 8: {
    bool fFirstMerge = nParameter % 2;
    bool fMspfMerge = fMspf? (nParameter / 2) % 2: false;
    bool fInner = (nParameter / 4) % 2;
    bool fOuter = (nParameter / 8) % 2;
    count -= t.RepeatAll(fFirstMerge, fMspfMerge, fMspf, fInner, fOuter);
    break;
  }
  default:
    std::cout << "Unknown transduction type " << nType << std::endl;
  }
  assert(t.Verify());
  assert(count == t.CountWires());
  return t.GenerateAig();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManTransductionTt()

Gia_Man_t * Gia_ManTransductionTt	(	Gia_Man_t *	pGia,
		int	nType,
		int	fMspf,
		int	nRandom,
		int	nSortType,
		int	nPiShuffle,
		int	nParameter,
		int	fLevel,
		Gia_Man_t *	pExdc,
		int	fNewLine,
		int	nVerbose )

extern

Definition at line 91 of file giaTransduction.cpp.

                                                                                                                                                                                              {
  if(nRandom) {
    srand(nRandom);
    nSortType = rand() % 4;
    nPiShuffle = rand();
    nParameter = rand() % 16;
  }
  NewTt::Param p;
  Transduction::Transduction<NewTt::Man, NewTt::Param, NewTt::lit, 0xffffffff> t(pGia, nVerbose, fNewLine, nSortType, nPiShuffle, fLevel, pExdc, p);
  int count = t.CountWires();
  switch(nType) {
  case 0:
    count -= fMspf? t.Mspf(): t.Cspf();
    break;
  case 1:
    count -= t.Resub(fMspf);
    break;
  case 2:
    count -= t.ResubMono(fMspf);
    break;
  case 3:
    count -= t.ResubShared(fMspf);
    break;
  case 4:
    count -= t.RepeatResub(false, fMspf);
    break;
  case 5:
    count -= t.RepeatResub(true, fMspf);
    break;
  case 6: {
    bool fInner = (nParameter / 4) % 2;
    count -= t.RepeatInner(fMspf, fInner);
    break;
  }
  case 7: {
    bool fInner = (nParameter / 4) % 2;
    bool fOuter = (nParameter / 8) % 2;
    count -= t.RepeatOuter(fMspf, fInner, fOuter);
    break;
  }
  case 8: {
    bool fFirstMerge = nParameter % 2;
    bool fMspfMerge = fMspf? (nParameter / 2) % 2: false;
    bool fInner = (nParameter / 4) % 2;
    bool fOuter = (nParameter / 8) % 2;
    count -= t.RepeatAll(fFirstMerge, fMspfMerge, fMspf, fInner, fOuter);
    break;
  }
  default:
    std::cout << "Unknown transduction type " << nType << std::endl;
  }
  assert(t.Verify());
  assert(count == t.CountWires());
  return t.GenerateAig();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManTransferMapping()

void Gia_ManTransferMapping	(	Gia_Man_t *	p,
		Gia_Man_t *	pGia )

extern

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

Synopsis [Transfers mapping from hie GIA to normalized GIA.]

Description [Hie GIA (pGia) points to normalized GIA (p).]

SideEffects []

SeeAlso []

Definition at line 2305 of file giaIf.c.

{
    Gia_Obj_t * pObj;
    int i, k, iFan, iPlace;
    if ( !Gia_ManHasMapping(pGia) )
        return;
    Gia_ManMappingVerify( pGia );
    Vec_IntFreeP( &p->vMapping );
    p->vMapping = Vec_IntAlloc( 2 * Gia_ManObjNum(p) );
    Vec_IntFill( p->vMapping, Gia_ManObjNum(p), 0 );
    Gia_ManForEachLut( pGia, i )
    {
        if ( Gia_ObjValue(Gia_ManObj(pGia, i)) == ~0 ) // handle dangling LUT
            continue;
        assert( !Abc_LitIsCompl(Gia_ObjValue(Gia_ManObj(pGia, i))) );
        pObj = Gia_ManObj( p, Abc_Lit2Var(Gia_ObjValue(Gia_ManObj(pGia, i))) );
        Vec_IntWriteEntry( p->vMapping, Gia_ObjId(p, pObj), Vec_IntSize(p->vMapping) );
        iPlace = Vec_IntSize( p->vMapping );
        Vec_IntPush( p->vMapping, Gia_ObjLutSize(pGia, i) );
        Gia_LutForEachFanin( pGia, i, iFan, k )
        {
            if ( Gia_ObjValue(Gia_ManObj(pGia, iFan)) == ~0 ) // handle dangling LUT fanin
                Vec_IntAddToEntry( p->vMapping, iPlace, -1 );
            else
                Vec_IntPush( p->vMapping, Abc_Lit2Var(Gia_ObjValue(Gia_ManObj(pGia, iFan))) );
        }
        iFan = Abc_Lit2Var( Gia_ObjValue(Gia_ManObj(pGia, Abc_AbsInt(Gia_ObjLutMuxId(pGia, i)))) );
        Vec_IntPush( p->vMapping, Gia_ObjLutIsMux(pGia, i) ? -iFan : iFan );
    }
    Gia_ManMappingVerify( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManTransferPacking()

void Gia_ManTransferPacking	(	Gia_Man_t *	p,
		Gia_Man_t *	pGia )

extern

Definition at line 2336 of file giaIf.c.

{
    Vec_Int_t * vPackingNew;
    Gia_Obj_t * pObj, * pObjNew;
    int i, k, Entry, nEntries, nEntries2;
    if ( pGia->vPacking == NULL )
        return;
    nEntries = Vec_IntEntry( pGia->vPacking, 0 );
    nEntries2 = 0;
    // create new packing info
    vPackingNew = Vec_IntAlloc( Vec_IntSize(pGia->vPacking) );
    Vec_IntPush( vPackingNew, nEntries );
    Vec_IntForEachEntryStart( pGia->vPacking, Entry, i, 1 )
    {
        assert( Entry > 0 && Entry < 4 );
        Vec_IntPush( vPackingNew, Entry );
        i++;
        for ( k = 0; k < Entry; k++, i++ )
        {
            pObj = Gia_ManObj(pGia, Vec_IntEntry(pGia->vPacking, i));
            pObjNew = Gia_ManObj(p, Abc_Lit2Var(Gia_ObjValue(pObj)));
            assert( Gia_ObjIsLut(pGia, Gia_ObjId(pGia, pObj)) );
            assert( Gia_ObjIsLut(p, Gia_ObjId(p, pObjNew)) );
            Vec_IntPush( vPackingNew, Gia_ObjId(p, pObjNew) );
//            printf( "%d -> %d  ", Vec_IntEntry(pGia->vPacking, i), Gia_ObjId(p, pObjNew) );
        }
        i--;
        nEntries2++;
    }
    assert( nEntries == nEntries2 );
    // attach packing info
    assert( p->vPacking == NULL );
    p->vPacking = vPackingNew;
}

Here is the caller graph for this function:

◆ Gia_ManTransferTiming()

void Gia_ManTransferTiming	(	Gia_Man_t *	p,
		Gia_Man_t *	pGia )

extern

Definition at line 2370 of file giaIf.c.

{
    if ( p == pGia )
        return;
    if ( pGia->vCiArrs || pGia->vCoReqs || pGia->vCoArrs || pGia->vCoAttrs )
    {
        p->vCiArrs     = pGia->vCiArrs;     pGia->vCiArrs    = NULL;
        p->vCoReqs     = pGia->vCoReqs;     pGia->vCoReqs    = NULL;
        p->vCoArrs     = pGia->vCoArrs;     pGia->vCoArrs    = NULL;
        p->vCoAttrs    = pGia->vCoAttrs;    pGia->vCoAttrs   = NULL;
        p->And2Delay   = pGia->And2Delay;
    }
    if ( pGia->vInArrs || pGia->vOutReqs )
    {
        p->vInArrs     = pGia->vInArrs;     pGia->vInArrs     = NULL;
        p->vOutReqs    = pGia->vOutReqs;    pGia->vOutReqs    = NULL;
        p->DefInArrs   = pGia->DefInArrs;
        p->DefOutReqs  = pGia->DefOutReqs;
        p->And2Delay   = pGia->And2Delay;
    }
    if ( pGia->vNamesIn || pGia->vNamesOut || pGia->vNamesNode )
    {
        p->vNamesIn     = pGia->vNamesIn;     pGia->vNamesIn     = NULL;
        p->vNamesOut    = pGia->vNamesOut;    pGia->vNamesOut    = NULL;
        p->vNamesNode   = pGia->vNamesNode;   pGia->vNamesNode   = NULL;
    }
    if ( pGia->vConfigs || pGia->pCellStr )
    {
        p->vConfigs     = pGia->vConfigs;     pGia->vConfigs     = NULL;
        p->pCellStr     = pGia->pCellStr;     pGia->pCellStr     = NULL;
    }
    if ( pGia->pManTime == NULL )
        return;
    p->pManTime    = pGia->pManTime;    pGia->pManTime    = NULL;
    p->pAigExtra   = pGia->pAigExtra;   pGia->pAigExtra   = NULL;
    p->vRegClasses = pGia->vRegClasses; pGia->vRegClasses = NULL;
    p->vRegInits   = pGia->vRegInits;   pGia->vRegInits = NULL;
    p->nAnd2Delay  = pGia->nAnd2Delay;  pGia->nAnd2Delay  = 0;
}

Here is the caller graph for this function:

◆ Gia_ManTransformMiter()

Gia_Man_t * Gia_ManTransformMiter ( Gia_Man_t * p )

extern

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

Synopsis [Transforms the circuit into a regular miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 3376 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pObj2;
    int i, iLit;
    assert( (Gia_ManPoNum(p) & 1) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
    {
        pObj2 = Gia_ManPo( p, ++i );
        iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(pObj2) );
        Gia_ManAppendCo( pNew, iLit );
    }
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    if ( p->vNamesIn )
        pNew->vNamesIn = Vec_PtrDupStr(p->vNamesIn);
    if ( p->vNamesOut )
        pNew->vNamesOut = Gia_ManMiterNames(p->vNamesOut, Gia_ManPoNum(p));
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManTransformMiter2()

Gia_Man_t * Gia_ManTransformMiter2 ( Gia_Man_t * p )

extern

Definition at line 3409 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pObj2;
    int i, iLit, nPart = Gia_ManPoNum(p)/2;
    assert( (Gia_ManPoNum(p) & 1) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
    {
        if ( i == nPart )
            break;
        pObj2 = Gia_ManPo( p, nPart + i );
        iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(pObj2) );
        Gia_ManAppendCo( pNew, iLit );
    }
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManTransformToDual()

Gia_Man_t * Gia_ManTransformToDual ( Gia_Man_t * p )

extern

Definition at line 3440 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
    {
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Gia_ManAppendCo( pNew, 0 );
    }
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManTransformTwoWord2DualOutput()

Gia_Man_t * Gia_ManTransformTwoWord2DualOutput ( Gia_Man_t * p )

extern

Definition at line 3465 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj, * pObj2;
    int i, nPart = Gia_ManPoNum(p)/2;
    assert( (Gia_ManPoNum(p) & 1) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManHashAlloc( pNew );
    Gia_ManForEachCi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi( pNew );
    Gia_ManForEachAnd( p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManForEachPo( p, pObj, i )
    {
        if ( i == nPart )
            break;
        pObj2 = Gia_ManPo( p, nPart + i );
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj2) );
    }
    Gia_ManForEachRi( p, pObj, i )
        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManTtopt()

Gia_Man_t * Gia_ManTtopt	(	Gia_Man_t *	p,
		int	nIns,
		int	nOuts,
		int	nRounds )

extern

Definition at line 1109 of file giaTtopt.cpp.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    Vec_Int_t * vSupp;
    word v;
    word * pTruth;
    int i, g, k, nInputs;
    Gia_ManLevelNum( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManForEachCi( p, pObj, k )
        Gia_ManAppendCi( pNew );
    Gia_ObjComputeTruthTableStart( p, nIns );
    Gia_ManHashStart( pNew );
    for ( g = 0; g < Gia_ManCoNum(p); g += nOuts )
    {
        vSupp = Gia_ManCollectSuppNew( p, g, nOuts );
        nInputs = Vec_IntSize( vSupp );
        Ttopt::TruthTableReo tt( nInputs, nOuts );
        for ( k = 0; k < nOuts; k++ )
        {
            pObj = Gia_ManCo( p, g+k );
            pTruth = Gia_ObjComputeTruthTableCut( p, Gia_ObjFanin0(pObj), vSupp );
            if ( nInputs >= 6 )
                for ( i = 0; i < tt.nSize; i++ )
                    tt.t[i + tt.nSize * k] = Gia_ObjFaninC0(pObj)? ~pTruth[i]: pTruth[i];
            else
            {
                i = k * (1 << nInputs);
                v = (Gia_ObjFaninC0(pObj)? ~pTruth[0]: pTruth[0]) & tt.ones[nInputs];
                tt.t[i / tt.ww] |= v << (i % tt.ww);
            }
        }
        tt.RandomSiftReo( nRounds );
        Ttopt::TruthTable tt2( nInputs, nOuts );
        tt2.t = tt.t;
        tt2.Reo( tt.vLevels );
        tt2.BDDGenerateAig( pNew, vSupp );
        Vec_IntFree( vSupp );
    }
    Gia_ObjComputeTruthTableStop( p );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManTtoptCare()

Gia_Man_t * Gia_ManTtoptCare	(	Gia_Man_t *	p,
		int	nIns,
		int	nOuts,
		int	nRounds,
		char *	pFileName,
		int	nRarity )

extern

Definition at line 1157 of file giaTtopt.cpp.

{
    int fVerbose = 0;
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    Vec_Int_t * vSupp;
    word v;
    word * pTruth, * pCare;
    int i, g, k, nInputs;
    Vec_Wrd_t * vSimI = Vec_WrdReadBin( pFileName, fVerbose );
    Gia_ManLevelNum( p );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManForEachCi( p, pObj, k )
        Gia_ManAppendCi( pNew );
    Gia_ObjComputeTruthTableStart( p, nIns );
    Gia_ManHashStart( pNew );
    for ( g = 0; g < Gia_ManCoNum(p); g += nOuts )
    {
        vSupp = Gia_ManCollectSuppNew( p, g, nOuts );
        nInputs = Vec_IntSize( vSupp );
        if ( nInputs == 0 )
        {
            for ( k = 0; k < nOuts; k++ )
            {
                pObj = Gia_ManCo( p, g+k );
                pTruth = Gia_ObjComputeTruthTableCut( p, Gia_ObjFanin0(pObj), vSupp );
                Gia_ManAppendCo( pNew, pTruth[0] & 1 );
            }
            Vec_IntFree( vSupp );
            continue;
        }
        Ttopt::TruthTableLevelTSM tt( nInputs, nOuts );
        for ( k = 0; k < nOuts; k++ )
        {
            pObj = Gia_ManCo( p, g+k );
            pTruth = Gia_ObjComputeTruthTableCut( p, Gia_ObjFanin0(pObj), vSupp );
            if ( nInputs >= 6 )
                for ( i = 0; i < tt.nSize; i++ )
                    tt.t[i + tt.nSize * k] = Gia_ObjFaninC0(pObj)? ~pTruth[i]: pTruth[i];
            else
            {
                i = k * (1 << nInputs);
                v = (Gia_ObjFaninC0(pObj)? ~pTruth[0]: pTruth[0]) & tt.ones[nInputs];
                tt.t[i / tt.ww] |= v << (i % tt.ww);
            }
        }
        i = 1 << Vec_IntSize( vSupp );
        pCare = Gia_ManCountFraction( p, vSimI, vSupp, nRarity, fVerbose, &i );
        tt.care[0] = pCare[0];
        for ( i = 1; i < tt.nSize; i++ )
            tt.care[i] = pCare[i];
        ABC_FREE( pCare );
        tt.RandomSiftReo( nRounds );
        tt.Optimize();
        tt.BDDGenerateAig( pNew, vSupp );
        Vec_IntFree( vSupp );
    }
    Gia_ObjComputeTruthTableStop( p );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    Vec_WrdFreeP( &vSimI );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_ManUnrollAbs()

Vec_Ptr_t * Gia_ManUnrollAbs	(	Gia_Man_t *	p,
		int	nFrames )

extern

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

Synopsis [Duplicates AIG for unrolling.]

Description []

SideEffects []

SeeAlso []

Definition at line 155 of file giaFrames.c.

{
    int fVerbose = 0;
    Vec_Ptr_t * vFrames;
    Vec_Int_t * vLimit, * vOne;
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int nObjBits, nObjMask;
    int f, fMax, k, Entry, Prev, iStart, iStop, Size;
    // get the bitmasks
    nObjBits = Abc_Base2Log( Gia_ManObjNum(p) );
    nObjMask = (1 << nObjBits) - 1;
    assert( Gia_ManObjNum(p) <= nObjMask );
    // derive the tents
    vLimit = Vec_IntAlloc( 1000 );
    pNew = Gia_ManUnrollDup( p, vLimit );
    // debug printout
    if ( fVerbose )
    {
        Prev = 1;
        printf( "Tents: " );
        Vec_IntForEachEntryStart( vLimit, Entry, k, 1 )
            printf( "%d=%d ", k, Entry-Prev ), Prev = Entry;
        printf( "  Unused=%d", Gia_ManObjNum(p) - Gia_ManObjNum(pNew) );
        printf( "\n" );
    }
    // create abstraction
    vFrames = Vec_PtrAlloc( Vec_IntSize(vLimit) );
    for ( fMax = 0; fMax < nFrames; fMax++ )
    {
        Size = (fMax+1 < Vec_IntSize(vLimit)) ? Vec_IntEntry(vLimit, fMax+1) : Gia_ManObjNum(pNew);
        vOne = Vec_IntAlloc( Size );
        for ( f = 0; f <= fMax; f++ )
        {
            iStart = (f   < Vec_IntSize(vLimit)) ? Vec_IntEntry(vLimit, f  ) : 0;
            iStop  = (f+1 < Vec_IntSize(vLimit)) ? Vec_IntEntry(vLimit, f+1) : 0;
            for ( k = iStop - 1; k >= iStart; k-- )
            {
                assert( Gia_ManObj(pNew, k)->Value > 0 );
                pObj  = Gia_ManObj(p, Gia_ManObj(pNew, k)->Value);
                if ( Gia_ObjIsCo(pObj) || Gia_ObjIsPi(p, pObj) )
                    continue;
                assert( Gia_ObjIsRo(p, pObj) || Gia_ObjIsAnd(pObj) );
                Entry = ((fMax-f) << nObjBits) | Gia_ObjId(p, pObj);
                Vec_IntPush( vOne, Entry );
//                printf( "%d ", Gia_ManObj(pNew, k)->Value );
            }
//            printf( "\n" );
        }
        // add in reverse topological order
        Vec_IntSort( vOne, 1 );
        Vec_PtrPush( vFrames, vOne );
        assert( Vec_IntSize(vOne) <= Size - 1 );
    }
    Vec_IntFree( vLimit );
    Gia_ManStop( pNew );
    return vFrames;
}

Here is the call graph for this function:

◆ Gia_ManUnrollAdd()

void * Gia_ManUnrollAdd	(	void *	pMan,
		int	fMax )

extern

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

Synopsis [Computes init/non-init unrolling without flops.]

Description []

SideEffects []

SeeAlso []

Definition at line 437 of file giaFrames.c.

{
    Gia_ManUnr_t * p = (Gia_ManUnr_t *)pMan;
    Gia_Obj_t * pObj;
    int f, i, Lit = 0, Beg, End;
    // create PIs on demand
    if ( p->pPars->fSaveLastLit ) 
        for ( i = 0; i < Gia_ManPiNum(p->pAig); i++ )
            Gia_ManAppendCi(p->pNew);
    // unroll another timeframe
    for ( f = 0; f < fMax; f++ )
    {
        if ( Vec_IntSize(p->vLimit) <= fMax-f )
            continue;
        Beg = Vec_IntEntry( p->vLimit, fMax-f-1 );
        End = Vec_IntEntry( p->vLimit, fMax-f );
        for ( i = Beg; i < End; i++ )
        {
            pObj = Gia_ManObj( p->pOrder, i );
            if ( Gia_ObjIsAnd(pObj) )
                Lit = Gia_ManHashAnd( p->pNew, Gia_ObjUnrReadCopy0(p, pObj, i), Gia_ObjUnrReadCopy1(p, pObj, i) );
            else if ( Gia_ObjIsCo(pObj) )
            {
                Lit = Gia_ObjUnrReadCopy0(p, pObj, i);
                if ( f == fMax-1 )
                {
                    if ( p->pPars->fSaveLastLit )
                        p->LastLit = Lit;
                    else
                        Gia_ManAppendCo( p->pNew, Lit );
                }
            }
            else if ( Gia_ObjIsCi(pObj) )
                Lit = Gia_ObjUnrReadCi( p, i, f, p->pNew );
            else assert( 0 );
            assert( Lit >= 0 );
            Gia_ObjUnrWrite( p, i, Lit ); // should be exactly one call for each obj!
        }
    }
    return p->pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUnrollAndCofactor()

Gia_Man_t * Gia_ManUnrollAndCofactor	(	Gia_Man_t *	p,
		int	nFrames,
		int	nFanMax,
		int	fVerbose )

extern

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

Synopsis [Unrolls initialized timeframes while cofactoring some vars.]

Description []

SideEffects []

SeeAlso []

Definition at line 403 of file giaEnable.c.

{
    Vec_Int_t * vCofSigs, * vTemp;
    Gia_Man_t * pAig, * pFrames, * pNew;
    // compute initialized timeframes
    pFrames  = Gia_ManUnrollInit( p, nFrames );
    pAig     = Gia_ManCleanup( pFrames );
    // compute and remap set/reset/enable signals
    vCofSigs = Gia_ManDetectSeqSignalsWithFanout( p, nFanMax, fVerbose );
    vCofSigs = Gia_ManTransferFrames( p, pFrames, nFrames, pAig, vTemp = vCofSigs );
    Vec_IntFree( vTemp );
    Gia_ManStop( pFrames );
    Vec_IntErase( &p->vCopies );
    // cofactor all these variables
    pNew = Gia_ManDupCofAllInt( pAig, vCofSigs, fVerbose );
    Vec_IntFree( vCofSigs );
    Gia_ManStop( pAig );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUnrollDup()

Gia_Man_t * Gia_ManUnrollDup	(	Gia_Man_t *	p,
		Vec_Int_t *	vLimit )

extern

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

Synopsis [Duplicates AIG for unrolling.]

Description []

SideEffects []

SeeAlso []

Definition at line 107 of file giaFrames.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    assert( Vec_IntSize(vLimit) == 0 );
    pNew = Gia_ManStart( Gia_ManObjNum(p) );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
 
    // save constant class
    Gia_ManFillValue( p );
    Gia_ManConst0(p)->Value = 0;
    Vec_IntPush( vLimit, Gia_ManObjNum(pNew) );
 
    // create first class
    Gia_ManForEachPo( p, pObj, i )
        Gia_ManUnrollDup_rec( pNew, pObj, Gia_ObjId(p, pObj) );
    Vec_IntPush( vLimit, Gia_ManObjNum(pNew) );
 
    // create next classes
    for ( i = 1; i < Gia_ManObjNum(pNew); i++ )
    {
        if ( i == Vec_IntEntryLast(vLimit) )
            Vec_IntPush( vLimit, Gia_ManObjNum(pNew) );
        pObj = Gia_ManObj( p, Gia_ManObj(pNew, i)->Value );
        if ( Gia_ObjIsRo(p, pObj) )
        {
            pObj = Gia_ObjRoToRi(p, pObj);
            assert( !~pObj->Value );
            Gia_ManUnrollDup_rec( pNew, pObj, Gia_ObjId(p, pObj) );
        }
    }
    Gia_ManSetRegNum( pNew, 0 );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUnrollLastLit()

int Gia_ManUnrollLastLit ( void * pMan )

extern

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

Synopsis [Read the last literal.]

Description []

SideEffects []

SeeAlso []

Definition at line 490 of file giaFrames.c.

{
    Gia_ManUnr_t * p = (Gia_ManUnr_t *)pMan;
    return p->LastLit;
}

Here is the caller graph for this function:

◆ Gia_ManUnrollStart()

void * Gia_ManUnrollStart	(	Gia_Man_t *	pAig,
		Gia_ParFra_t *	pPars )

extern

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

Synopsis [Computes init/non-init unrolling without flops.]

Description []

SideEffects []

SeeAlso []

Definition at line 402 of file giaFrames.c.

{
    Gia_ManUnr_t * p;
    int f, i;
    // start 
    p = Gia_ManUnrStart( pAig, pPars );
    // start timeframes
    assert( p->pNew == NULL );
    p->pNew = Gia_ManStart( 10000 );
    p->pNew->pName = Abc_UtilStrsav( p->pAig->pName );
    p->pNew->pSpec = Abc_UtilStrsav( p->pAig->pSpec );
    Gia_ManHashAlloc( p->pNew );
    // create combinational inputs
    if ( !p->pPars->fSaveLastLit ) // only in the case when unrolling depth is known
        for ( f = 0; f < p->pPars->nFrames; f++ )
            for ( i = 0; i < Gia_ManPiNum(p->pAig); i++ )
                Gia_ManAppendCi(p->pNew);
    // create flop outputs
    if ( !p->pPars->fInit ) // only in the case when initialization is not performed
        for ( i = 0; i < Gia_ManRegNum(p->pAig); i++ )
            Gia_ManAppendCi(p->pNew);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUnrollStop()

void Gia_ManUnrollStop ( void * pMan )

extern

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

Synopsis [Deletes manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 310 of file giaFrames.c.

{
    Gia_ManUnr_t * p = (Gia_ManUnr_t *)pMan;
    Gia_ManStopP( &p->pOrder );
    Vec_IntFreeP( &p->vLimit );
    Vec_IntFreeP( &p->vRank );
    Vec_IntFreeP( &p->vDegree );
    Vec_IntFreeP( &p->vDegDiff );
    Vec_IntFreeP( &p->vFirst );
    Vec_IntFreeP( &p->vStore );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUpdateCopy()

void Gia_ManUpdateCopy	(	Vec_Int_t *	vCopy,
		Gia_Man_t *	p )

extern

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_ManUpdateExtraAig()

Gia_Man_t * Gia_ManUpdateExtraAig	(	void *	pTime,
		Gia_Man_t *	p,
		Vec_Int_t *	vBoxPres )

extern

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

Synopsis [Update AIG of the holes.]

Description []

SideEffects []

SeeAlso []

Definition at line 694 of file giaTim.c.

{
    Gia_Man_t * pNew;
    Tim_Man_t * pManTime = (Tim_Man_t *)pTime;
    Vec_Int_t * vOutPres = Vec_IntAlloc( 100 );
    int i, k, curPo = 0;
    assert( Vec_IntSize(vBoxPres) == Tim_ManBoxNum(pManTime) );
    assert( Gia_ManCoNum(p) == Tim_ManCiNum(pManTime) - Tim_ManPiNum(pManTime) );
    for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
    {
        for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
            Vec_IntPush( vOutPres, Vec_IntEntry(vBoxPres, i) );
        curPo += Tim_ManBoxOutputNum(pManTime, i);
    }
    assert( curPo == Gia_ManCoNum(p) );
    pNew = Gia_ManDupOutputVec( p, vOutPres );
    Vec_IntFree( vOutPres );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUpdateExtraAig2()

Gia_Man_t * Gia_ManUpdateExtraAig2	(	void *	pTime,
		Gia_Man_t *	pAig,
		Vec_Int_t *	vBoxesLeft )

extern

Definition at line 713 of file giaTim.c.

{
    Gia_Man_t * pNew;
    Tim_Man_t * pManTime = (Tim_Man_t *)pTime;
    int nRealPis = Tim_ManPiNum(pManTime);
    Vec_Int_t * vOutsLeft = Vec_IntAlloc( 100 );
    int i, k, iBox, iOutFirst;
    assert( Vec_IntSize(vBoxesLeft) <= Tim_ManBoxNum(pManTime) );
    assert( Gia_ManCoNum(p) == Tim_ManCiNum(pManTime) - nRealPis );
    Vec_IntForEachEntry( vBoxesLeft, iBox, i )
    {
        iOutFirst = Tim_ManBoxOutputFirst(pManTime, iBox) - nRealPis;
        for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, iBox); k++ )
            Vec_IntPush( vOutsLeft, iOutFirst + k );
    }
    pNew = Gia_ManDupSelectedOutputs( p, vOutsLeft );
    Vec_IntFree( vOutsLeft );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUpdateMapping()

void Gia_ManUpdateMapping	(	Gia_Man_t *	p,
		Vec_Int_t *	vNodes,
		Vec_Wec_t *	vWin )

extern

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

Synopsis [Finds edge assignment.]

Description []

SideEffects []

SeeAlso []

Definition at line 610 of file giaEdge.c.

{
    int i, iNode;
    Vec_IntForEachEntry( vNodes, iNode, i )
        ABC_SWAP( Vec_Int_t, *Vec_WecEntry(p->vMapping2, iNode), *Vec_WecEntry(vWin, i) );
}

Here is the caller graph for this function:

◆ Gia_ManUpdateTimMan()

void * Gia_ManUpdateTimMan	(	Gia_Man_t *	p,
		Vec_Int_t *	vBoxPres )

extern

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

Synopsis [Update hierarchy/timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 668 of file giaTim.c.

{
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    assert( pManTime != NULL );
    assert( Vec_IntSize(vBoxPres) == Tim_ManBoxNum(pManTime) );
    return Tim_ManTrim( pManTime, vBoxPres );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManUpdateTimMan2()

void * Gia_ManUpdateTimMan2	(	Gia_Man_t *	p,
		Vec_Int_t *	vBoxesLeft,
		int	nTermsDiff )

extern

Definition at line 675 of file giaTim.c.

{
    Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
    assert( pManTime != NULL );
    assert( Vec_IntSize(vBoxesLeft) <= Tim_ManBoxNum(pManTime) );
    return Tim_ManReduce( pManTime, vBoxesLeft, nTermsDiff );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManVerifyCex()

int Gia_ManVerifyCex	(	Gia_Man_t *	pAig,
		Abc_Cex_t *	p,
		int	fDualOut )

extern

DECLARATIONS ///.

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

FileName [giaAbs.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Counter-example-guided abstraction refinement.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Resimulates the counter-example.]

Description []

SideEffects []

SeeAlso []

Definition at line 48 of file giaCex.c.

{
    Gia_Obj_t * pObj, * pObjRi, * pObjRo;
    int RetValue, i, k, iBit = 0;
    Gia_ManCleanMark0(pAig);
    Gia_ManForEachRo( pAig, pObj, i )
        pObj->fMark0 = Abc_InfoHasBit(p->pData, iBit++);
    for ( i = 0; i <= p->iFrame; i++ )
    {
        Gia_ManForEachPi( pAig, pObj, k )
            pObj->fMark0 = Abc_InfoHasBit(p->pData, iBit++);
        Gia_ManForEachAnd( pAig, pObj, k )
            pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & 
                           (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
        Gia_ManForEachCo( pAig, pObj, k )
            pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj);
        if ( i == p->iFrame )
            break;
        Gia_ManForEachRiRo( pAig, pObjRi, pObjRo, k )
        {
            pObjRo->fMark0 = pObjRi->fMark0;
        }
    }
    assert( iBit == p->nBits );
    if ( fDualOut )
        RetValue = Gia_ManPo(pAig, 2*p->iPo)->fMark0 ^ Gia_ManPo(pAig, 2*p->iPo+1)->fMark0;
    else
        RetValue = Gia_ManPo(pAig, p->iPo)->fMark0;
    Gia_ManCleanMark0(pAig);
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ManVerifyWithBoxes()

int Gia_ManVerifyWithBoxes	(	Gia_Man_t *	pGia,
		int	nBTLimit,
		int	nTimeLim,
		int	fSeq,
		int	fDumpFiles,
		int	fVerbose,
		char *	pFileSpec )

extern

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

Synopsis [Verify XAIG against its spec.]

Description []

SideEffects []

SeeAlso []

Definition at line 955 of file giaTim.c.

{
    int Status   = -1;
    Gia_Man_t * pSpec, * pGia0, * pGia1, * pMiter;
    Vec_Int_t * vBoxPres = NULL;
    if ( pFileSpec == NULL && pGia->pSpec == NULL )
    {
        printf( "Spec file is not given. Use standard flow.\n" );
        return Status;
    }
    if ( Gia_ManBoxNum(pGia) && pGia->pAigExtra == NULL )
    {
        printf( "Design has no box logic. Use standard flow.\n" );
        return Status;
    }
    // read original AIG
    pSpec = Gia_AigerRead( pFileSpec ? pFileSpec : pGia->pSpec, 0, 0, 0 );
    if ( Gia_ManBoxNum(pSpec) && pSpec->pAigExtra == NULL )
    {
        Gia_ManStop( pSpec );
        printf( "Spec has no box logic. Use standard flow.\n" );
        return Status;
    }
    // prepare miter
    if ( pGia->pManTime == NULL && pSpec->pManTime == NULL )
    {
        pGia0 = Gia_ManDup( pSpec );
        pGia1 = Gia_ManDup( pGia );
    }
    else
    {
        // if timing managers have different number of black boxes,
        // it is possible that some of the boxes are swept away
        if ( pSpec->pManTime && Tim_ManBlackBoxNum((Tim_Man_t *)pSpec->pManTime) > 0 && Gia_ManBoxNum(pGia) > 0 )
        {
            // specification cannot have fewer boxes than implementation
            if ( Gia_ManBoxNum(pSpec) < Gia_ManBoxNum(pGia) )
            {
                printf( "Spec has less boxes than the design. Cannot proceed.\n" );
                return Status;
            }
            // to align the boxes, find what boxes of pSpec are dropped in pGia
            if ( Gia_ManBoxNum(pSpec) > Gia_ManBoxNum(pGia) )
            {
                vBoxPres = Tim_ManAlignTwo( (Tim_Man_t *)pSpec->pManTime, (Tim_Man_t *)pGia->pManTime );
                if ( vBoxPres == NULL )
                {
                    printf( "Boxes of spec and design cannot be aligned. Cannot proceed.\n" );
                    return Status;
                }
            }
        }
        // collapse two designs
        if ( Gia_ManBoxNum(pSpec) > 0 )
            pGia0 = Gia_ManDupCollapse( pSpec, pSpec->pAigExtra, vBoxPres, fSeq );
        else
            pGia0 = Gia_ManDup( pSpec );
        if ( Gia_ManBoxNum(pGia) > 0 )
            pGia1 = Gia_ManDupCollapse( pGia,  pGia->pAigExtra,  NULL, fSeq  );
        else
            pGia1 = Gia_ManDup( pGia );
        Vec_IntFreeP( &vBoxPres );
    }
    if ( fDumpFiles )
    {
        char pFileName0[1000], pFileName1[1000];
        char * pNameGeneric = Extra_FileNameGeneric( pFileSpec ? pFileSpec : pGia->pSpec );
        sprintf( pFileName0, "%s_spec.aig", pNameGeneric );
        sprintf( pFileName1, "%s_impl.aig", pNameGeneric );
        Gia_AigerWrite( pGia0, pFileName0, 0, 0, 0 );
        Gia_AigerWrite( pGia1, pFileName1, 0, 0, 0 );
        ABC_FREE( pNameGeneric );
        printf( "Dumped two parts of the miter into files \"%s\" and \"%s\".\n", pFileName0, pFileName1 );
    }
    // compute the miter
    if ( fSeq )
    {
        pMiter = Gia_ManMiter( pGia0, pGia1, 0, 0, 1, 0, fVerbose );
        if ( pMiter )
        {
            Aig_Man_t * pMan;
            Fra_Sec_t SecPar, * pSecPar = &SecPar;
            Fra_SecSetDefaultParams( pSecPar );
            pSecPar->fRetimeFirst = 0;
            pSecPar->nBTLimit  = nBTLimit;
            pSecPar->TimeLimit = nTimeLim;
            pSecPar->fVerbose  = fVerbose;
            pMan = Gia_ManToAig( pMiter, 0 );
            Gia_ManStop( pMiter );
            Status = Fra_FraigSec( pMan, pSecPar, NULL );
            Aig_ManStop( pMan );
        }
    }
    else
    {
        pMiter = Gia_ManMiter( pGia0, pGia1, 0, 1, 0, 0, fVerbose );
        if ( pMiter )
        {
            Cec_ParCec_t ParsCec, * pPars = &ParsCec;
            Cec_ManCecSetDefaultParams( pPars );
            pPars->nBTLimit  = nBTLimit;
            pPars->TimeLimit = nTimeLim;
            pPars->fVerbose  = fVerbose;
            Status = Cec_ManVerify( pMiter, pPars );
            if ( pPars->iOutFail >= 0 )
                Abc_Print( 1, "Verification failed for at least one output (%d).\n", pPars->iOutFail );
            Gia_ManStop( pMiter );
        }
    }
    Gia_ManStop( pGia0 );
    Gia_ManStop( pGia1 );
    Gia_ManStop( pSpec );
    return Status;
}

Here is the call graph for this function:

◆ Gia_ManWriteMiniAig()

void Gia_ManWriteMiniAig	(	Gia_Man_t *	pGia,
		char *	pFileName )

extern

Definition at line 237 of file giaMini.c.

{
    Mini_Aig_t * p = Gia_ManToMiniAig( pGia );
    Mini_AigDump( p, pFileName );
    //Mini_AigDumpVerilog( "test_miniaig.v", "top", p );
    Mini_AigStop( p );
}

Here is the call graph for this function:

◆ Gia_ManWriteMiniLut()

void Gia_ManWriteMiniLut	(	Gia_Man_t *	pGia,
		char *	pFileName )

extern

Definition at line 596 of file giaMini.c.

{
    Mini_Lut_t * p = Gia_ManToMiniLut( pGia );
    Mini_LutDump( p, pFileName );
    Mini_LutStop( p );
}

Here is the call graph for this function:

◆ Gia_MmFixedEntryFetch()

char * Gia_MmFixedEntryFetch ( Gia_MmFixed_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 161 of file giaMem.c.

{
    char * pTemp;
    int i;
 
    // check if there are still free entries
    if ( p->nEntriesUsed == p->nEntriesAlloc )
    { // need to allocate more entries
        assert( p->pEntriesFree == NULL );
        if ( p->nChunks == p->nChunksAlloc )
        {
            p->nChunksAlloc *= 2;
            p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
        }
        p->pEntriesFree = ABC_ALLOC( char, p->nEntrySize * p->nChunkSize );
        p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
        // transform these entries into a linked list
        pTemp = p->pEntriesFree;
        for ( i = 1; i < p->nChunkSize; i++ )
        {
            *((char **)pTemp) = pTemp + p->nEntrySize;
            pTemp += p->nEntrySize;
        }
        // set the last link
        *((char **)pTemp) = NULL;
        // add the chunk to the chunk storage
        p->pChunks[ p->nChunks++ ] = p->pEntriesFree;
        // add to the number of entries allocated
        p->nEntriesAlloc += p->nChunkSize;
    }
    // incrememt the counter of used entries
    p->nEntriesUsed++;
    if ( p->nEntriesMax < p->nEntriesUsed )
        p->nEntriesMax = p->nEntriesUsed;
    // return the first entry in the free entry list
    pTemp = p->pEntriesFree;
    p->pEntriesFree = *((char **)pTemp);
    return pTemp;
}

Here is the caller graph for this function:

◆ Gia_MmFixedEntryRecycle()

void Gia_MmFixedEntryRecycle	(	Gia_MmFixed_t *	p,
		char *	pEntry )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 212 of file giaMem.c.

{
    // decrement the counter of used entries
    p->nEntriesUsed--;
    // add the entry to the linked list of free entries
    *((char **)pEntry) = p->pEntriesFree;
    p->pEntriesFree = pEntry;
}

Here is the caller graph for this function:

◆ Gia_MmFixedReadMaxEntriesUsed()

int Gia_MmFixedReadMaxEntriesUsed ( Gia_MmFixed_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 287 of file giaMem.c.

{
    return p->nEntriesMax;
}

◆ Gia_MmFixedReadMemUsage()

int Gia_MmFixedReadMemUsage ( Gia_MmFixed_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 271 of file giaMem.c.

{
    return p->nMemoryAlloc;
}

◆ Gia_MmFixedRestart()

void Gia_MmFixedRestart ( Gia_MmFixed_t * p )

extern

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

Synopsis []

Description [Relocates all the memory except the first chunk.]

SideEffects []

SeeAlso []

Definition at line 232 of file giaMem.c.

{
    int i;
    char * pTemp;
    if ( p->nChunks == 0 )
        return;
    // deallocate all chunks except the first one
    for ( i = 1; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    p->nChunks = 1;
    // transform these entries into a linked list
    pTemp = p->pChunks[0];
    for ( i = 1; i < p->nChunkSize; i++ )
    {
        *((char **)pTemp) = pTemp + p->nEntrySize;
        pTemp += p->nEntrySize;
    }
    // set the last link
    *((char **)pTemp) = NULL;
    // set the free entry list
    p->pEntriesFree  = p->pChunks[0];
    // set the correct statistics
    p->nMemoryAlloc  = p->nEntrySize * p->nChunkSize;
    p->nMemoryUsed   = 0;
    p->nEntriesAlloc = p->nChunkSize;
    p->nEntriesUsed  = 0;
}

◆ Gia_MmFixedStart()

Gia_MmFixed_t * Gia_MmFixedStart	(	int	nEntrySize,
		int	nEntriesMax )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Allocates memory pieces of fixed size.]

Description [The size of the chunk is computed as the minimum of 1024 entries and 64K. Can only work with entry size at least 4 byte long.]

SideEffects []

SeeAlso []

Definition at line 96 of file giaMem.c.

{
    Gia_MmFixed_t * p;
 
    p = ABC_ALLOC( Gia_MmFixed_t, 1 );
    memset( p, 0, sizeof(Gia_MmFixed_t) );
 
    p->nEntrySize    = nEntrySize;
    p->nEntriesAlloc = 0;
    p->nEntriesUsed  = 0;
    p->pEntriesFree  = NULL;
 
    p->nChunkSize = nEntriesMax / 8;
    if ( p->nChunkSize < 8 )
        p->nChunkSize = 8;
 
    p->nChunksAlloc  = 64;
    p->nChunks       = 0;
    p->pChunks       = ABC_ALLOC( char *, p->nChunksAlloc );
 
    p->nMemoryUsed   = 0;
    p->nMemoryAlloc  = 0;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_MmFixedStop()

void Gia_MmFixedStop	(	Gia_MmFixed_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 132 of file giaMem.c.

{
    int i;
    if ( p == NULL )
        return;
    if ( fVerbose )
    {
        printf( "Fixed memory manager: Entry = %5d. Chunk = %5d. Chunks used = %5d.\n",
            p->nEntrySize, p->nChunkSize, p->nChunks );
        printf( "   Entries used = %8d. Entries peak = %8d. Memory used = %8d. Memory alloc = %8d.\n",
            p->nEntriesUsed, p->nEntriesMax, p->nEntrySize * p->nEntriesUsed, p->nMemoryAlloc );
    }
    for ( i = 0; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    ABC_FREE( p->pChunks );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Gia_MmFlexEntryFetch()

char * Gia_MmFlexEntryFetch	(	Gia_MmFlex_t *	p,
		int	nBytes )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 366 of file giaMem.c.

{
    char * pTemp;
    // check if there are still free entries
    if ( p->pCurrent == NULL || p->pCurrent + nBytes > p->pEnd )
    { // need to allocate more entries
        if ( p->nChunks == p->nChunksAlloc )
        {
            p->nChunksAlloc *= 2;
            p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
        }
        if ( nBytes > p->nChunkSize )
        {
            // resize the chunk size if more memory is requested than it can give
            // (ideally, this should never happen)
            p->nChunkSize = 2 * nBytes;
        }
        p->pCurrent = ABC_ALLOC( char, p->nChunkSize );
        p->pEnd     = p->pCurrent + p->nChunkSize;
        p->nMemoryAlloc += p->nChunkSize;
        // add the chunk to the chunk storage
        p->pChunks[ p->nChunks++ ] = p->pCurrent;
    }
    assert( p->pCurrent + nBytes <= p->pEnd );
    // increment the counter of used entries
    p->nEntriesUsed++;
    // keep track of the memory used
    p->nMemoryUsed += nBytes;
    // return the next entry
    pTemp = p->pCurrent;
    p->pCurrent += nBytes;
    return pTemp;
}

◆ Gia_MmFlexReadMemUsage()

int Gia_MmFlexReadMemUsage ( Gia_MmFlex_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 439 of file giaMem.c.

{
    return p->nMemoryUsed;
}

◆ Gia_MmFlexRestart()

void Gia_MmFlexRestart ( Gia_MmFlex_t * p )

extern

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

Synopsis []

Description [Relocates all the memory except the first chunk.]

SideEffects []

SeeAlso []

Definition at line 411 of file giaMem.c.

{
    int i;
    if ( p->nChunks == 0 )
        return;
    // deallocate all chunks except the first one
    for ( i = 1; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    p->nChunks  = 1;
    p->nMemoryAlloc = p->nChunkSize;
    // transform these entries into a linked list
    p->pCurrent = p->pChunks[0];
    p->pEnd     = p->pCurrent + p->nChunkSize;
    p->nEntriesUsed = 0;
    p->nMemoryUsed = 0;
}

◆ Gia_MmFlexStart()

Gia_MmFlex_t * Gia_MmFlexStart ( )

extern

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

Synopsis [Allocates entries of flexible size.]

Description [Can only work with entry size at least 4 byte long.]

SideEffects []

SeeAlso []

Definition at line 305 of file giaMem.c.

{
    Gia_MmFlex_t * p;
 
    p = ABC_ALLOC( Gia_MmFlex_t, 1 );
    memset( p, 0, sizeof(Gia_MmFlex_t) );
 
    p->nEntriesUsed  = 0;
    p->pCurrent      = NULL;
    p->pEnd          = NULL;
 
    p->nChunkSize    = (1 << 18);
    p->nChunksAlloc  = 64;
    p->nChunks       = 0;
    p->pChunks       = ABC_ALLOC( char *, p->nChunksAlloc );
 
    p->nMemoryUsed   = 0;
    p->nMemoryAlloc  = 0;
    return p;
}

Here is the call graph for this function:

◆ Gia_MmFlexStop()

void Gia_MmFlexStop	(	Gia_MmFlex_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 337 of file giaMem.c.

{
    int i;
    if ( p == NULL )
        return;
    if ( fVerbose )
    {
        printf( "Flexible memory manager: Chunk size = %d. Chunks used = %d.\n",
            p->nChunkSize, p->nChunks );
        printf( "   Entries used = %d. Memory used = %d. Memory alloc = %d.\n",
            p->nEntriesUsed, p->nMemoryUsed, p->nMemoryAlloc );
    }
    for ( i = 0; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    ABC_FREE( p->pChunks );
    ABC_FREE( p );
}

◆ Gia_MmStepEntryFetch()

char * Gia_MmStepEntryFetch	(	Gia_MmStep_t *	p,
		int	nBytes )

extern

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

Synopsis [Creates the entry.]

Description []

SideEffects []

SeeAlso []

Definition at line 534 of file giaMem.c.

{
    if ( nBytes == 0 )
        return NULL;
    if ( nBytes > p->nMapSize )
    {
        if ( p->nChunks == p->nChunksAlloc )
        {
            p->nChunksAlloc *= 2;
            p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
        }
        p->pChunks[ p->nChunks++ ] = ABC_ALLOC( char, nBytes );
        return p->pChunks[p->nChunks-1];
    }
    return Gia_MmFixedEntryFetch( p->pMap[nBytes] );
}

Here is the call graph for this function:

◆ Gia_MmStepEntryRecycle()

void Gia_MmStepEntryRecycle	(	Gia_MmStep_t *	p,
		char *	pEntry,
		int	nBytes )

extern

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

Synopsis [Recycles the entry.]

Description []

SideEffects []

SeeAlso []

Definition at line 563 of file giaMem.c.

{
    if ( nBytes == 0 )
        return;
    if ( nBytes > p->nMapSize )
    {
//        ABC_FREE( pEntry );
        return;
    }
    Gia_MmFixedEntryRecycle( p->pMap[nBytes], pEntry );
}

Here is the call graph for this function:

◆ Gia_MmStepReadMemUsage()

int Gia_MmStepReadMemUsage ( Gia_MmStep_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 586 of file giaMem.c.

{
    int i, nMemTotal = 0;
    for ( i = 0; i < p->nMems; i++ )
        nMemTotal += p->pMems[i]->nMemoryAlloc;
    return nMemTotal;
}

◆ Gia_MmStepStart()

Gia_MmStep_t * Gia_MmStepStart ( int nSteps )

extern

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

Synopsis [Starts the hierarchical memory manager.]

Description [This manager can allocate entries of any size. Iternally they are mapped into the entries with the number of bytes equal to the power of 2. The smallest entry size is 8 bytes. The next one is 16 bytes etc. So, if the user requests 6 bytes, he gets 8 byte entry. If we asks for 25 bytes, he gets 32 byte entry etc. The input parameters "nSteps" says how many fixed memory managers are employed internally. Calling this procedure with nSteps equal to 10 results in 10 hierarchically arranged internal memory managers, which can allocate up to 4096 (1Kb) entries. Requests for larger entries are handed over to malloc() and then ABC_FREE()ed.]

SideEffects []

SeeAlso []

Definition at line 468 of file giaMem.c.

{
    Gia_MmStep_t * p;
    int i, k;
    p = ABC_ALLOC( Gia_MmStep_t, 1 );
    memset( p, 0, sizeof(Gia_MmStep_t) );
    p->nMems = nSteps;
    // start the fixed memory managers
    p->pMems = ABC_ALLOC( Gia_MmFixed_t *, p->nMems );
    for ( i = 0; i < p->nMems; i++ )
        p->pMems[i] = Gia_MmFixedStart( (8<<i), (1<<13) );
    // set up the mapping of the required memory size into the corresponding manager
    p->nMapSize = (4<<p->nMems);
    p->pMap = ABC_ALLOC( Gia_MmFixed_t *, p->nMapSize+1 );
    p->pMap[0] = NULL;
    for ( k = 1; k <= 4; k++ )
        p->pMap[k] = p->pMems[0];
    for ( i = 0; i < p->nMems; i++ )
        for ( k = (4<<i)+1; k <= (8<<i); k++ )
            p->pMap[k] = p->pMems[i];
//for ( i = 1; i < 100; i ++ )
//printf( "%10d: size = %10d\n", i, p->pMap[i]->nEntrySize );
    p->nChunksAlloc  = 64;
    p->nChunks       = 0;
    p->pChunks       = ABC_ALLOC( char *, p->nChunksAlloc );
    return p;
}

Here is the call graph for this function:

◆ Gia_MmStepStop()

void Gia_MmStepStop	(	Gia_MmStep_t *	p,
		int	fVerbose )

extern

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

Synopsis [Stops the memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 507 of file giaMem.c.

{
    int i;
    for ( i = 0; i < p->nMems; i++ )
        Gia_MmFixedStop( p->pMems[i], fVerbose );
    if ( p->nChunksAlloc )
    {
        for ( i = 0; i < p->nChunks; i++ )
            ABC_FREE( p->pChunks[i] );
        ABC_FREE( p->pChunks );
    }
    ABC_FREE( p->pMems );
    ABC_FREE( p->pMap );
    ABC_FREE( p );
}

Here is the call graph for this function:

◆ Gia_NodeMffcMapping()

int Gia_NodeMffcMapping ( Gia_Man_t * p )

extern

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_NodeMffcSize()

int Gia_NodeMffcSize	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode )

extern

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 )

extern

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 )

extern

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_ObjAddFanout()

void Gia_ObjAddFanout	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Gia_Obj_t *	pFanout )

extern

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

Synopsis [Adds fanout (pFanout) of node (pObj).]

Description []

SideEffects []

SeeAlso []

Definition at line 116 of file giaFanout.c.

{
    int iFan, * pFirst, * pPrevC, * pNextC, * pPrev, * pNext;
    assert( p->pFanData );
    assert( !Gia_IsComplement(pObj) && !Gia_IsComplement(pFanout) );
    assert( Gia_ObjId(p, pFanout) > 0 );
    if ( Gia_ObjId(p, pObj) >= p->nFansAlloc || Gia_ObjId(p, pFanout) >= p->nFansAlloc )
    {
        int nFansAlloc = 2 * Abc_MaxInt( Gia_ObjId(p, pObj), Gia_ObjId(p, pFanout) ); 
        p->pFanData = ABC_REALLOC( int, p->pFanData, 5 * nFansAlloc );
        memset( p->pFanData + 5 * p->nFansAlloc, 0, sizeof(int) * 5 * (nFansAlloc - p->nFansAlloc) );
        p->nFansAlloc = nFansAlloc;
    }
    assert( Gia_ObjId(p, pObj) < p->nFansAlloc && Gia_ObjId(p, pFanout) < p->nFansAlloc );
    iFan   = Gia_FanoutCreate( Gia_ObjId(p, pFanout), Gia_ObjWhatFanin(p, pFanout, pObj) );
    pPrevC = Gia_FanoutPrev( p->pFanData, iFan );
    pNextC = Gia_FanoutNext( p->pFanData, iFan );
    pFirst = Gia_FanoutObj( p->pFanData, Gia_ObjId(p, pObj) );
    if ( *pFirst == 0 )
    {
        *pFirst = iFan;
        *pPrevC = iFan;
        *pNextC = iFan;
    }
    else
    {
        pPrev = Gia_FanoutPrev( p->pFanData, *pFirst );
        pNext = Gia_FanoutNext( p->pFanData, *pPrev );
        assert( *pNext == *pFirst );
        *pPrevC = *pPrev;
        *pNextC = *pFirst;
        *pPrev  = iFan;
        *pNext  = iFan;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjCheckEdge()

int Gia_ObjCheckEdge	(	Gia_Man_t *	p,
		int	iObj,
		int	iNext )

extern

Definition at line 172 of file giaEdge.c.

{
    return Gia_ObjHaveEdge( p, iObj, iNext );
}

Here is the caller graph for this function:

◆ Gia_ObjCheckMffc()

int Gia_ObjCheckMffc	(	Gia_Man_t *	p,
		Gia_Obj_t *	pRoot,
		int	Limit,
		Vec_Int_t *	vNodes,
		Vec_Int_t *	vLeaves,
		Vec_Int_t *	vInners )

extern

Definition at line 71 of file giaResub.c.

{
    int RetValue, iObj, i;
    Vec_IntClear( vNodes );
    RetValue = Gia_ObjCheckMffc_rec( p, pRoot, Limit, vNodes );
    if ( RetValue )
    {
        Vec_IntClear( vLeaves );
        Vec_IntClear( vInners );
        Vec_IntSort( vNodes, 0 );
        Vec_IntForEachEntry( vNodes, iObj, i )
            if ( Gia_ObjRefNumId(p, iObj) > 0 || Gia_ObjIsCi(Gia_ManObj(p, iObj)) )
            {
                if ( !Vec_IntSize(vLeaves) || Vec_IntEntryLast(vLeaves) != iObj )
                    Vec_IntPush( vLeaves, iObj );
            }
            else
            {
                if ( !Vec_IntSize(vInners) || Vec_IntEntryLast(vInners) != iObj )
                    Vec_IntPush( vInners, iObj );
            }
        Vec_IntPush( vInners, Gia_ObjId(p, pRoot) );
    }
    Vec_IntForEachEntry( vNodes, iObj, i )
        Gia_ObjRefIncId( p, iObj );
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjCollectInternal()

void Gia_ObjCollectInternal	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

Definition at line 429 of file giaTruth.c.

{
    Vec_IntClear( p->vTtNodes );
    Gia_ObjCollectInternal_rec( p, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjComputeTruth6Cis()

word Gia_ObjComputeTruth6Cis	(	Gia_Man_t *	p,
		int	iLit,
		Vec_Int_t *	vSupp,
		Vec_Wrd_t *	vTemp )

extern

Definition at line 345 of file giaTruth.c.

{
    int iObj = Abc_Lit2Var(iLit); 
    Vec_IntClear( vSupp );
    if ( !iObj ) return Abc_LitIsCompl(iLit) ? ~(word)0 : (word)0;
    Gia_ManIncrementTravId( p );
    Gia_ObjComputeTruth6CisSupport_rec( p, iObj, vSupp );
    if ( Vec_IntSize(vSupp) > 6 )
        return 0;
    Gia_ObjComputeTruth6( p, iObj, vSupp, vTemp );
    return Abc_LitIsCompl(iLit) ? ~Vec_WrdEntry(vTemp, iObj) : Vec_WrdEntry(vTemp, iObj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjComputeTruthTable()

word * Gia_ObjComputeTruthTable	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

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

Synopsis [Computing the truth table for GIA object.]

Description [The truth table should be used by the calling application (or saved into the user's storage) before this procedure is called again.]

SideEffects []

SeeAlso []

Definition at line 447 of file giaTruth.c.

{
    Gia_Obj_t * pTemp, * pRoot;
    word * pTruth, * pTruthL, * pTruth0, * pTruth1;
    int i;
    if ( p->vTtMemory == NULL )
    {
        p->nTtVars   = Gia_ManPiNum( p );
        p->nTtWords  = Abc_Truth6WordNum( p->nTtVars );
        p->vTtNums   = Vec_IntStart( Gia_ManObjNum(p) + 1000 );
        p->vTtNodes  = Vec_IntAlloc( 256 );
        p->vTtInputs = Vec_PtrAllocTruthTables( Abc_MaxInt(6, p->nTtVars) );
        p->vTtMemory = Vec_WrdStart( p->nTtWords * 256 );
    }
    else
    {
        // make sure the number of primary inputs did not change 
        // since the truth table computation storage was prepared
        assert( p->nTtVars == Gia_ManPiNum(p) );
    }
    // extend ID numbers
    if ( Vec_IntSize(p->vTtNums) < Gia_ManObjNum(p) )
        Vec_IntFillExtra( p->vTtNums, Gia_ManObjNum(p), 0 );
    // collect internal nodes
    pRoot = Gia_ObjIsCo(pObj) ? Gia_ObjFanin0(pObj) : pObj;
    Gia_ObjCollectInternal( p, pRoot );
    // extend TT storage
    if ( Vec_WrdSize(p->vTtMemory) < p->nTtWords * (Vec_IntSize(p->vTtNodes) + 2) )
        Vec_WrdFillExtra( p->vTtMemory, p->nTtWords * (Vec_IntSize(p->vTtNodes) + 2), 0 );
    // compute the truth table for internal nodes
    Gia_ManForEachObjVec( p->vTtNodes, p, pTemp, i )
    {
        pTemp->fMark0 = 0; // unmark nodes marked by Gia_ObjCollectInternal()
        pTruth  = Gla_ObjTruthNode(p, pTemp);
        pTruthL = pTruth + p->nTtWords;
        pTruth0 = Gia_ObjIsAnd(Gia_ObjFanin0(pTemp)) ? Gla_ObjTruthNode(p, Gia_ObjFanin0(pTemp)) : Gla_ObjTruthElem(p, Gia_ObjCioId(Gia_ObjFanin0(pTemp)) );
        pTruth1 = Gia_ObjIsAnd(Gia_ObjFanin1(pTemp)) ? Gla_ObjTruthNode(p, Gia_ObjFanin1(pTemp)) : Gla_ObjTruthElem(p, Gia_ObjCioId(Gia_ObjFanin1(pTemp)) );
        if ( Gia_ObjFaninC0(pTemp) )
        {
            if ( Gia_ObjFaninC1(pTemp) )
                while ( pTruth < pTruthL )
                    *pTruth++ = ~*pTruth0++ & ~*pTruth1++;
            else
                while ( pTruth < pTruthL )
                    *pTruth++ = ~*pTruth0++ &  *pTruth1++;
        }
        else
        {
            if ( Gia_ObjFaninC1(pTemp) )
                while ( pTruth < pTruthL )
                    *pTruth++ =  *pTruth0++ & ~*pTruth1++;
            else
                while ( pTruth < pTruthL )
                    *pTruth++ =  *pTruth0++ &  *pTruth1++;
        }
    }
    // compute the final table
    if ( Gia_ObjIsConst0(pRoot) )
        pTruth = Gla_ObjTruthConst0( p, Gla_ObjTruthFree1(p) );
    else if ( Gia_ObjIsPi(p, pRoot) )
        pTruth = Gla_ObjTruthElem( p, Gia_ObjCioId(pRoot) );
    else if ( Gia_ObjIsAnd(pRoot) )
        pTruth = Gla_ObjTruthNode( p, pRoot );
    else
        pTruth = NULL;
    return Gla_ObjTruthDup( p, Gla_ObjTruthFree2(p), pTruth, Gia_ObjIsCo(pObj) && Gia_ObjFaninC0(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjComputeTruthTable6()

word Gia_ObjComputeTruthTable6	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Vec_Int_t *	vSupp,
		Vec_Wrd_t *	vTruths )

extern

Definition at line 386 of file giaTruth.c.

{
    Gia_Obj_t * pLeaf;
    int i;
    assert( Vec_IntSize(vSupp) <= 6 );
    assert( Gia_ObjIsAnd(pObj) );
    assert( !pObj->fMark0 );
    Vec_WrdClear( vTruths );
    Gia_ManIncrementTravId( p );
    Gia_ManForEachObjVec( vSupp, p, pLeaf, i )
    {
        assert( pLeaf->fMark0 || Gia_ObjIsRo(p, pLeaf) );
        pLeaf->Value = Vec_WrdSize(vTruths);
        Vec_WrdPush( vTruths, s_Truth6[i] );
        Gia_ObjSetTravIdCurrent(p, pLeaf);
    }
    Gia_ObjComputeTruthTable6_rec( p, pObj, vTruths );
    return Vec_WrdEntryLast( vTruths );
}

Here is the call graph for this function:

◆ Gia_ObjComputeTruthTable6Lut()

word Gia_ObjComputeTruthTable6Lut	(	Gia_Man_t *	p,
		int	iObj,
		Vec_Wrd_t *	vTemp )

extern

Definition at line 289 of file giaTruth.c.

{
    int i, Fanin;
    assert( Vec_WrdSize(vTemp) == Gia_ManObjNum(p) );
    assert( Gia_ObjIsLut(p, iObj) );
    Gia_ManIncrementTravId( p );
    Gia_LutForEachFanin( p, iObj, Fanin, i )
    {
        Gia_ObjSetTravIdCurrentId( p, Fanin );
        Vec_WrdWriteEntry( vTemp, Fanin, s_Truth6[i] );
    }
    assert( i <= 6 );
    Gia_ObjComputeTruthTable6Lut_rec( p, iObj, vTemp );
    return Vec_WrdEntry( vTemp, iObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjComputeTruthTableCut()

word * Gia_ObjComputeTruthTableCut	(	Gia_Man_t *	p,
		Gia_Obj_t *	pRoot,
		Vec_Int_t *	vLeaves )

extern

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

Synopsis [Computes the truth table of pRoot in terms of leaves.]

Description [The root cannot be one of the leaves.]

SideEffects []

SeeAlso []

Definition at line 628 of file giaTruth.c.

{
    Gia_Obj_t * pTemp;
    word * pTruth, * pTruthL, * pTruth0, * pTruth1;
    int i, iObj, Id0, Id1, Index = Vec_IntFind(vLeaves, Gia_ObjId(p, pRoot));
    assert( p->vTtMemory != NULL );
    assert( Vec_IntSize(vLeaves) <= p->nTtVars );
    if ( Index >= 0 )
        return Gla_ObjTruthElem( p, Index );    
    if ( Gia_ObjIsConst0(pRoot) )
    {
        if ( Vec_WrdSize(p->vTtMemory) < p->nTtWords )
            Vec_WrdFillExtra( p->vTtMemory, p->nTtWords, 0 );
        return Gla_ObjTruthConst0( p, Gla_ObjTruthFree1(p) );
    }
    assert( Gia_ObjIsAnd(pRoot) );
    // extend ID numbers
    if ( Vec_IntSize(p->vTtNums) < Gia_ManObjNum(p) )
        Vec_IntFillExtra( p->vTtNums, Gia_ManObjNum(p), -ABC_INFINITY );
    // collect internal nodes
    Gia_ObjCollectInternalCut( p, Gia_ObjId(p, pRoot), vLeaves );
    // extend TT storage
    if ( Vec_WrdSize(p->vTtMemory) < p->nTtWords * (Vec_IntSize(p->vTtNodes) + 2) )
        Vec_WrdFillExtra( p->vTtMemory, p->nTtWords * (Vec_IntSize(p->vTtNodes) + 2), 0 );
    // compute the truth table for internal nodes
    Vec_IntForEachEntryStart( p->vTtNodes, iObj, i, 1 )
    {
        assert( i == Gia_ObjNumId(p, iObj) );
        pTemp   = Gia_ManObj( p, iObj );
        pTruth  = Gla_ObjTruthNodeId( p, i );  
        pTruthL = pTruth + p->nTtWords;
        Id0 = Gia_ObjNumId( p, Gia_ObjFaninId0(pTemp, iObj) );
        Id1 = Gia_ObjNumId( p, Gia_ObjFaninId1(pTemp, iObj) );
        pTruth0 = (Id0 > 0) ? Gla_ObjTruthNodeId(p, Id0) : Gla_ObjTruthElem(p, -Id0);
        pTruth1 = (Id1 > 0) ? Gla_ObjTruthNodeId(p, Id1) : Gla_ObjTruthElem(p, -Id1);
        if ( Gia_ObjFaninC0(pTemp) )
        {
            if ( Gia_ObjFaninC1(pTemp) )
                while ( pTruth < pTruthL )
                    *pTruth++ = ~*pTruth0++ & ~*pTruth1++;
            else
                while ( pTruth < pTruthL )
                    *pTruth++ = ~*pTruth0++ &  *pTruth1++;
        }
        else
        {
            if ( Gia_ObjFaninC1(pTemp) )
                while ( pTruth < pTruthL )
                    *pTruth++ =  *pTruth0++ & ~*pTruth1++;
            else
                while ( pTruth < pTruthL )
                    *pTruth++ =  *pTruth0++ &  *pTruth1++;
        }
    }
    pTruth = Gla_ObjTruthNode( p, pRoot );
    // unmark leaves marked by Gia_ObjCollectInternal()
    Vec_IntForEachEntry( vLeaves, iObj, i )
        Gia_ObjResetNumId( p, iObj );
    Vec_IntForEachEntryStart( p->vTtNodes, iObj, i, 1 )
        Gia_ObjResetNumId( p, iObj );
    return pTruth;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ObjComputeTruthTableStart()

void Gia_ObjComputeTruthTableStart	(	Gia_Man_t *	p,
		int	nVarsMax )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 552 of file giaTruth.c.

{
    assert( p->vTtMemory == NULL );
    p->nTtVars   = nVarsMax;
    p->nTtWords  = Abc_Truth6WordNum( p->nTtVars );
    p->vTtNodes  = Vec_IntAlloc( 256 );
    p->vTtInputs = Vec_PtrAllocTruthTables( Abc_MaxInt(6, p->nTtVars) );
    p->vTtMemory = Vec_WrdStart( p->nTtWords * 64 );
    p->vTtNums   = Vec_IntAlloc( Gia_ManObjNum(p) + 1000 );
    Vec_IntFill( p->vTtNums, Vec_IntCap(p->vTtNums), -ABC_INFINITY );
    if ( nVarsMax >= 6 ) {
        word * pTruth; int i;
        Vec_PtrForEachEntry( word *, p->vTtInputs, pTruth, i )
            Abc_TtFlipVar5( pTruth, nVarsMax );
    }
}

Here is the caller graph for this function:

◆ Gia_ObjComputeTruthTableStop()

void Gia_ObjComputeTruthTableStop ( Gia_Man_t * p )

extern

Definition at line 568 of file giaTruth.c.

{
    p->nTtVars   = 0;
    p->nTtWords  = 0;
    Vec_IntFreeP( &p->vTtNums );
    Vec_IntFreeP( &p->vTtNodes );
    Vec_PtrFreeP( &p->vTtInputs );
    Vec_WrdFreeP( &p->vTtMemory );
}

Here is the caller graph for this function:

◆ Gia_ObjIsMuxType()

int Gia_ObjIsMuxType ( Gia_Obj_t * pNode )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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_ObjRemoveFanout()

void Gia_ObjRemoveFanout	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj,
		Gia_Obj_t *	pFanout )

extern

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

Synopsis [Removes fanout (pFanout) of node (pObj).]

Description []

SideEffects []

SeeAlso []

Definition at line 163 of file giaFanout.c.

{
    int iFan, * pFirst, * pPrevC, * pNextC, * pPrev, * pNext;
    assert( p->pFanData && Gia_ObjId(p, pObj) < p->nFansAlloc && Gia_ObjId(p, pFanout) < p->nFansAlloc );
    assert( !Gia_IsComplement(pObj) && !Gia_IsComplement(pFanout) );
    assert( Gia_ObjId(p, pFanout) > 0 );
    iFan   = Gia_FanoutCreate( Gia_ObjId(p, pFanout), Gia_ObjWhatFanin(p, pFanout, pObj) );
    pPrevC = Gia_FanoutPrev( p->pFanData, iFan );
    pNextC = Gia_FanoutNext( p->pFanData, iFan );
    pPrev  = Gia_FanoutPrev( p->pFanData, *pNextC );
    pNext  = Gia_FanoutNext( p->pFanData, *pPrevC );
    assert( *pPrev == iFan );
    assert( *pNext == iFan );
    pFirst = Gia_FanoutObj( p->pFanData, Gia_ObjId(p, pObj) );
    assert( *pFirst > 0 );
    if ( *pFirst == iFan )
    {
        if ( *pNextC == iFan )
        {
            *pFirst = 0;
            *pPrev  = 0;
            *pNext  = 0;
            *pPrevC = 0;
            *pNextC = 0;
            return;
        }
        *pFirst = *pNextC;
    }
    *pPrev  = *pPrevC;
    *pNext  = *pNextC;
    *pPrevC = 0;
    *pNextC = 0;
}

◆ Gia_ObjSetPhase()

void Gia_ObjSetPhase	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj )

extern

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_ResubToTruth6()

word Gia_ResubToTruth6 ( Vec_Int_t * vResub )

extern

Definition at line 73 of file giaDecs.c.

{
    word Res;
    int iRoot = Vec_IntEntryLast(vResub);
    if ( iRoot < 2 )
        return iRoot ? ~(word)0 : 0;
    assert( iRoot != 2 && iRoot != 3 );
    Res = Gia_ResubToTruth6_rec( vResub, Abc_Lit2Var(iRoot)-2, Gia_ResubVarNum(vResub) );
    return Abc_LitIsCompl(iRoot) ? ~Res : Res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_ResubVarNum()

int Gia_ResubVarNum ( Vec_Int_t * vResub )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 51 of file giaDecs.c.

{
    if ( Vec_IntSize(vResub) == 1 )
        return Vec_IntEntryLast(vResub) >= 2;
    return Vec_IntEntryLast(vResub)/2 - Vec_IntSize(vResub)/2 - 1;
}

Here is the caller graph for this function:

◆ Gia_SatVerifyPattern()

void Gia_SatVerifyPattern	(	Gia_Man_t *	p,
		Gia_Obj_t *	pRoot,
		Vec_Int_t *	vCex,
		Vec_Int_t *	vVisit )

extern

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

Synopsis [Checks if the counter-examples asserts the output.]

Description [Assumes that fMark0 and fMark1 are clean. Leaves them clean.]

SideEffects []

SeeAlso []

Definition at line 93 of file giaPat.c.

{
    Gia_Obj_t * pObj;
    int i, Entry, Value, Value0, Value1;
    assert( Gia_ObjIsCo(pRoot) );
    assert( !Gia_ObjIsConst0(Gia_ObjFanin0(pRoot)) );
    // collect nodes and initialized them to x
    Gia_SatCollectCone( p, Gia_ObjFanin0(pRoot), vVisit );
    // set binary values to nodes in the counter-example
    Vec_IntForEachEntry( vCex, Entry, i )
//        Sat_ObjSetXValue( Gia_ManObj(p, Abc_Lit2Var(Entry)), Abc_LitIsCompl(Entry)? GIA_ZER : GIA_ONE );
        Sat_ObjSetXValue( Gia_ManCi(p, Abc_Lit2Var(Entry)), Abc_LitIsCompl(Entry)? GIA_ZER : GIA_ONE );
    // simulate
    Gia_ManForEachObjVec( vVisit, p, pObj, i )
    {
        if ( Gia_ObjIsCi(pObj) )
            continue;
        assert( Gia_ObjIsAnd(pObj) );
        Value0 = Sat_ObjXValue( Gia_ObjFanin0(pObj) );
        Value1 = Sat_ObjXValue( Gia_ObjFanin1(pObj) );
        Value = Gia_XsimAndCond( Value0, Gia_ObjFaninC0(pObj), Value1, Gia_ObjFaninC1(pObj) );
        Sat_ObjSetXValue( pObj, Value );
    }
    Value = Sat_ObjXValue( Gia_ObjFanin0(pRoot) );
    Value = Gia_XsimNotCond( Value, Gia_ObjFaninC0(pRoot) );
    if ( Value != GIA_ONE )
        printf( "Gia_SatVerifyPattern(): Verification FAILED.\n" );
//    else
//        printf( "Gia_SatVerifyPattern(): Verification succeeded.\n" );
//    assert( Value == GIA_ONE );
    // clean the nodes
    Gia_ManForEachObjVec( vVisit, p, pObj, i )
        Sat_ObjSetXValue( pObj, 0 );
}

Here is the call graph for this function:

◆ Gia_SimDataCiExt()

unsigned * Gia_SimDataCiExt	(	Gia_ManSim_t *	p,
		int	i )

extern

Definition at line 36 of file giaSim.c.

36{ return Gia_SimDataCi(p, i); }

◆ Gia_SimDataCoExt()

unsigned * Gia_SimDataCoExt	(	Gia_ManSim_t *	p,
		int	i )

extern

Definition at line 37 of file giaSim.c.

37{ return Gia_SimDataCo(p, i); }

◆ Gia_SimDataExt()

unsigned * Gia_SimDataExt	(	Gia_ManSim_t *	p,
		int	i )

extern

Definition at line 35 of file giaSim.c.

35{ return Gia_SimData(p, i); }

◆ Gia_SortFloats()

int * Gia_SortFloats	(	float *	pArray,
		int *	pPerm,
		int	nSize )

extern

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

Synopsis [Sorts the array of floating point numbers.]

Description []

SideEffects []

SeeAlso []

Definition at line 251 of file giaSort.c.

{
    int i;
    if ( pPerm == NULL )
    {
        pPerm = ABC_ALLOC( int, nSize );
        for ( i = 0; i < nSize; i++ )
            pPerm[i] = i;
    }
    minisat_sort3( pArray, pPerm, nSize );
//    for ( i = 1; i < nSize; i++ )
//        assert( pArray[i-1] <= pArray[i] );
    return pPerm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_SweeperCheckEquiv()

int Gia_SweeperCheckEquiv	(	Gia_Man_t *	pGia,
		int	Probe1,
		int	Probe2 )

extern

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

Synopsis [Runs equivalence test for probes.]

Description []

SideEffects []

SeeAlso []

Definition at line 789 of file giaSweeper.c.

{
    Swp_Man_t * p = (Swp_Man_t *)pGia->pData;
    int iLitOld, iLitNew, iLitAig, pLitsSat[2], RetValue, RetValue1, ProbeId, i;
    abctime clk;
    p->nSatCalls++;
    assert( p->pSat != NULL );
    p->vCexUser = NULL;
 
    // get the literals
    iLitOld = Gia_SweeperProbeLit( pGia, Probe1 );
    iLitNew = Gia_SweeperProbeLit( pGia, Probe2 );
    // if the literals are identical, the probes are equivalent
    if ( iLitOld == iLitNew )
        return 1;
    // if the literals are opposites, the probes are not equivalent
    if ( Abc_LitRegular(iLitOld) == Abc_LitRegular(iLitNew) )
    {
        Vec_IntFill( p->vCexSwp, Gia_ManPiNum(pGia), 2 );
        p->vCexUser = p->vCexSwp;
        return 0;
    }
    // order the literals
    if ( iLitOld < iLitNew )
        ABC_SWAP( int, iLitOld, iLitNew );
    assert( iLitOld > iLitNew );
 
    // create logic cones and the array of assumptions
    Vec_IntClear( p->vCondAssump );
    Vec_IntForEachEntry( p->vCondProbes, ProbeId, i )
    {
        iLitAig = Gia_SweeperProbeLit( pGia, ProbeId );
        Gia_ManCnfNodeAddToSolver( p, Abc_Lit2Var(iLitAig) );
        Vec_IntPush( p->vCondAssump, Abc_LitNot(Swp_ManLit2Lit(p, iLitAig)) );
    }
    Gia_ManCnfNodeAddToSolver( p, Abc_Lit2Var(iLitOld) );
    Gia_ManCnfNodeAddToSolver( p, Abc_Lit2Var(iLitNew) );
    sat_solver_compress( p->pSat );
 
    // set the SAT literals
    pLitsSat[0] = Swp_ManLit2Lit( p, iLitOld );
    pLitsSat[1] = Swp_ManLit2Lit( p, iLitNew );
 
    // solve under assumptions
    // A = 1; B = 0     OR     A = 1; B = 1 
    Vec_IntPush( p->vCondAssump, pLitsSat[0] );
    Vec_IntPush( p->vCondAssump, Abc_LitNot(pLitsSat[1]) );
 
    // set runtime limit for this call
    if ( p->nTimeOut )
        sat_solver_set_runtime_limit( p->pSat, p->nTimeOut * CLOCKS_PER_SEC + Abc_Clock() );
 
clk = Abc_Clock();
    RetValue1 = sat_solver_solve( p->pSat, Vec_IntArray(p->vCondAssump), Vec_IntArray(p->vCondAssump) + Vec_IntSize(p->vCondAssump), 
        (ABC_INT64_T)p->nConfMax, (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0 );
    Vec_IntShrink( p->vCondAssump, Vec_IntSize(p->vCondAssump) - 2 );
p->timeSat += Abc_Clock() - clk;
    if ( RetValue1 == l_False )
    {
        pLitsSat[0] = Abc_LitNot( pLitsSat[0] );
        RetValue = sat_solver_addclause( p->pSat, pLitsSat, pLitsSat + 2 );
        assert( RetValue );
        pLitsSat[0] = Abc_LitNot( pLitsSat[0] );
p->timeSatUnsat += Abc_Clock() - clk;
        p->nSatCallsUnsat++;
    }
    else if ( RetValue1 == l_True )
    {
        p->vCexUser = Gia_ManGetCex( p->pGia, p->vId2Lit, p->pSat, p->vCexSwp );
p->timeSatSat += Abc_Clock() - clk;
        p->nSatCallsSat++;
        return 0;
    }
    else // if ( RetValue1 == l_Undef )
    {
p->timeSatUndec += Abc_Clock() - clk;
        p->nSatCallsUndec++;
        return -1;
    }
 
    // if the old node was constant 0, we already know the answer
    if ( Gia_ManIsConstLit(iLitNew) )
    {
        p->nSatProofs++;
        return 1;
    }
 
    // solve under assumptions
    // A = 0; B = 1     OR     A = 0; B = 0 
    Vec_IntPush( p->vCondAssump, Abc_LitNot(pLitsSat[0]) );
    Vec_IntPush( p->vCondAssump, pLitsSat[1] );
 
clk = Abc_Clock();
    RetValue1 = sat_solver_solve( p->pSat, Vec_IntArray(p->vCondAssump), Vec_IntArray(p->vCondAssump) + Vec_IntSize(p->vCondAssump), 
        (ABC_INT64_T)p->nConfMax, (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0 );
    Vec_IntShrink( p->vCondAssump, Vec_IntSize(p->vCondAssump) - 2 );
p->timeSat += Abc_Clock() - clk;
    if ( RetValue1 == l_False )
    {
        pLitsSat[1] = Abc_LitNot( pLitsSat[1] );
        RetValue = sat_solver_addclause( p->pSat, pLitsSat, pLitsSat + 2 );
        assert( RetValue );
        pLitsSat[1] = Abc_LitNot( pLitsSat[1] );
p->timeSatUnsat += Abc_Clock() - clk;
        p->nSatCallsUnsat++;
    }
    else if ( RetValue1 == l_True )
    {
        p->vCexUser = Gia_ManGetCex( p->pGia, p->vId2Lit, p->pSat, p->vCexSwp );
p->timeSatSat += Abc_Clock() - clk;
        p->nSatCallsSat++;
        return 0;
    }
    else // if ( RetValue1 == l_Undef )
    {
p->timeSatUndec += Abc_Clock() - clk;
        p->nSatCallsUndec++;
        return -1;
    }
    // return SAT proof
    p->nSatProofs++;
    return 1;
}

Here is the call graph for this function:

◆ Gia_SweeperCleanup()

Gia_Man_t * Gia_SweeperCleanup	(	Gia_Man_t *	p,
		char *	pCommLime )

extern

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

Synopsis [Sweeper cleanup.]

Description [Returns new GIA with sweeper defined, which is the same as the original sweeper, with all the dangling logic removed and SAT solver restarted. The probe IDs are guaranteed to have the same logic functions as in the original manager.]

SideEffects [The input manager is deleted inside this procedure.]

SeeAlso []

Definition at line 461 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    Vec_Int_t * vObjIds;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, iLit, ProbeId;
 
    // collect all internal nodes pointed to by currently-used probes
    Gia_ManIncrementTravId( p );
    vObjIds = Vec_IntAlloc( 1000 );
    Vec_IntForEachEntry( pSwp->vProbes, iLit, ProbeId )
    {
        if ( iLit < 0 ) continue;
        pObj = Gia_Lit2Obj( p, iLit );
        Gia_ManExtract_rec( p, Gia_Regular(pObj), vObjIds );
    }
    // create new manager
    pNew = Gia_ManStart( 1 + Gia_ManPiNum(p) + Vec_IntSize(vObjIds) + 100 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    // create internal nodes
    Gia_ManHashStart( pNew );
    Gia_ManForEachObjVec( vObjIds, p, pObj, i )
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    Gia_ManHashStop( pNew );
    // create outputs
    Vec_IntForEachEntry( pSwp->vProbes, iLit, ProbeId )
    {
        if ( iLit < 0 ) continue;
        pObj = Gia_Lit2Obj( p, iLit );
        iLit = Gia_Regular(pObj)->Value ^ Gia_IsComplement(pObj);
        Vec_IntWriteEntry( pSwp->vProbes, ProbeId, iLit );
    }
    Vec_IntFree( vObjIds );
    // duplicate if needed
    if ( Gia_ManHasDangling(pNew) )
    {
        pNew = Gia_ManCleanup( pTemp = pNew );
        Gia_ManStop( pTemp );
    }
    // execute command line
    if ( pCommLime )
    {
        // set pNew to be current GIA in ABC
        Abc_FrameUpdateGia( Abc_FrameGetGlobalFrame(), pNew );
        // execute command line pCommLine using Abc_CmdCommandExecute()
        Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), pCommLime );
        // get pNew to be current GIA in ABC     
        pNew = Abc_FrameGetGia( Abc_FrameGetGlobalFrame() );
    }
    // restart the SAT solver
    Vec_IntClear( pSwp->vId2Lit );
    sat_solver_delete( pSwp->pSat );
    pSwp->pSat         = sat_solver_new();
    pSwp->nSatVars     = 1;
    sat_solver_setnvars( pSwp->pSat, 1000 );
    Swp_ManSetObj2Lit( pSwp, 0, (iLit = Abc_Var2Lit(pSwp->nSatVars++, 0)) );
    iLit = Abc_LitNot(iLit);
    sat_solver_addclause( pSwp->pSat, &iLit, &iLit + 1 );
    pSwp->timeStart    = Abc_Clock();
    // return the result
    pNew->pData = p->pData; p->pData = NULL;
    Gia_ManStop( p );
    return pNew;
}

Here is the call graph for this function:

◆ Gia_SweeperCollectValidProbeIds()

Vec_Int_t * Gia_SweeperCollectValidProbeIds ( Gia_Man_t * p )

extern

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

Synopsis [This procedure returns indexes of all currently defined valid probes.]

Description []

SideEffects []

SeeAlso []

Definition at line 295 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    Vec_Int_t * vProbeIds = Vec_IntAlloc( 1000 );
    int iLit, ProbeId;
    Vec_IntForEachEntry( pSwp->vProbes, iLit, ProbeId )
    {
        if ( iLit < 0 ) continue;
        Vec_IntPush( vProbeIds, ProbeId );
    }
    return vProbeIds;
}

◆ Gia_SweeperCondCheckUnsat()

int Gia_SweeperCondCheckUnsat ( Gia_Man_t * pGia )

extern

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

Synopsis [Returns 1 if the set of conditions is UNSAT (0 if SAT; -1 if undecided).]

Description []

SideEffects []

SeeAlso []

Definition at line 924 of file giaSweeper.c.

{
    Swp_Man_t * p = (Swp_Man_t *)pGia->pData;
    int RetValue, ProbeId, iLitAig, i;
    abctime clk;
    assert( p->pSat != NULL );
    p->nSatCalls++;
    p->vCexUser = NULL;
 
    // create logic cones and the array of assumptions
    Vec_IntClear( p->vCondAssump );
    Vec_IntForEachEntry( p->vCondProbes, ProbeId, i )
    {
        iLitAig = Gia_SweeperProbeLit( pGia, ProbeId );
        Gia_ManCnfNodeAddToSolver( p, Abc_Lit2Var(iLitAig) );
        Vec_IntPush( p->vCondAssump, Abc_LitNot(Swp_ManLit2Lit(p, iLitAig)) );
    }
    sat_solver_compress( p->pSat );
 
    // set runtime limit for this call
    if ( p->nTimeOut )
        sat_solver_set_runtime_limit( p->pSat, p->nTimeOut * CLOCKS_PER_SEC + Abc_Clock() );
 
clk = Abc_Clock();
    RetValue = sat_solver_solve( p->pSat, Vec_IntArray(p->vCondAssump), Vec_IntArray(p->vCondAssump) + Vec_IntSize(p->vCondAssump), 
        (ABC_INT64_T)p->nConfMax, (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0 );
p->timeSat += Abc_Clock() - clk;
    if ( RetValue == l_False )
    {
        assert( Vec_IntSize(p->vCondProbes) > 0 );
p->timeSatUnsat += Abc_Clock() - clk;
        p->nSatCallsUnsat++;
        p->nSatProofs++;
        return 1;
    }
    else if ( RetValue == l_True )
    {
        p->vCexUser = Gia_ManGetCex( p->pGia, p->vId2Lit, p->pSat, p->vCexSwp );
p->timeSatSat += Abc_Clock() - clk;
        p->nSatCallsSat++;
        return 0;
    }
    else // if ( RetValue1 == l_Undef )
    {
p->timeSatUndec += Abc_Clock() - clk;
        p->nSatCallsUndec++;
        return -1;
    }
}

Here is the call graph for this function:

◆ Gia_SweeperCondPop()

int Gia_SweeperCondPop ( Gia_Man_t * p )

extern

Definition at line 324 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    return Vec_IntPop( pSwp->vCondProbes );
}

◆ Gia_SweeperCondPush()

void Gia_SweeperCondPush	(	Gia_Man_t *	p,
		int	ProbeId )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 319 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    Vec_IntPush( pSwp->vCondProbes, ProbeId );
}

Here is the caller graph for this function:

◆ Gia_SweeperCondVector()

Vec_Int_t * Gia_SweeperCondVector ( Gia_Man_t * p )

extern

Definition at line 329 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    return pSwp->vCondProbes;
}

Here is the caller graph for this function:

◆ Gia_SweeperExtractUserLogic()

Gia_Man_t * Gia_SweeperExtractUserLogic	(	Gia_Man_t *	p,
		Vec_Int_t *	vProbeIds,
		Vec_Ptr_t *	vInNames,
		Vec_Ptr_t *	vOutNames )

extern

Definition at line 358 of file giaSweeper.c.

{
    Vec_Int_t * vObjIds, * vValues;
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i, ProbeId;
    assert( vInNames  == NULL || Gia_ManPiNum(p) == Vec_PtrSize(vInNames) );
    assert( vOutNames == NULL || Vec_IntSize(vProbeIds) == Vec_PtrSize(vOutNames) );
    // create new
    Gia_ManIncrementTravId( p );
    vObjIds = Vec_IntAlloc( 1000 );
    Vec_IntForEachEntry( vProbeIds, ProbeId, i )
    {
        pObj = Gia_Lit2Obj( p, Gia_SweeperProbeLit(p, ProbeId) );
        Gia_ManExtract_rec( p, Gia_Regular(pObj), vObjIds );
    }
    // create new manager
    pNew = Gia_ManStart( 1 + Gia_ManPiNum(p) + Vec_IntSize(vObjIds) + Vec_IntSize(vProbeIds) + 100 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Gia_ManConst0(p)->Value = 0;
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = Gia_ManAppendCi(pNew);
    // create internal nodes
    Gia_ManHashStart( pNew );
    vValues = Vec_IntAlloc( Vec_IntSize(vObjIds) );
    Gia_ManForEachObjVec( vObjIds, p, pObj, i )
    {
        Vec_IntPush( vValues, pObj->Value );
        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    }
    Gia_ManHashStop( pNew );
    // create outputs
    Vec_IntForEachEntry( vProbeIds, ProbeId, i )
    {
        pObj = Gia_Lit2Obj( p, Gia_SweeperProbeLit(p, ProbeId) );
        Gia_ManAppendCo( pNew, Gia_Regular(pObj)->Value ^ Gia_IsComplement(pObj) );
    }
    // return the values back
    Gia_ManForEachPi( p, pObj, i )
        pObj->Value = 0;
    Gia_ManForEachObjVec( vObjIds, p, pObj, i )
        pObj->Value = Vec_IntEntry( vValues, i );
    Vec_IntFree( vObjIds );
    Vec_IntFree( vValues );
    // duplicate if needed
    if ( Gia_ManHasDangling(pNew) )
    {
        pNew = Gia_ManCleanup( pTemp = pNew );
        Gia_ManStop( pTemp );
    }
    // copy names if present
    if ( vInNames )
        pNew->vNamesIn = Vec_PtrDupStr( vInNames );
    if ( vOutNames )
        pNew->vNamesOut = Vec_PtrDupStr( vOutNames );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_SweeperFraig()

int Gia_SweeperFraig	(	Gia_Man_t *	p,
		Vec_Int_t *	vProbeIds,
		char *	pCommLime,
		int	nWords,
		int	nConfs,
		int	fVerify,
		int	fVerbose )

extern

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

Synopsis [Procedure to perform conditional fraig sweeping on separate logic cones.]

Description [The procedure takes GIA with the sweeper defined. The sweeper is assumed to have some conditions currently pushed, which will be used as constraints for fraig sweeping. The second argument (vProbes) contains the array of probe IDs pointing to the user's logic cones to be SAT swept. Finally, the optional command line (pCommLine) is an ABC command line to be applied to the resulting GIA after SAT sweeping before it is grafted back into the original GIA manager. The return value is the status (success/failure) and the array of original probes possibly pointing to the new literals in the original GIA manager, corresponding to the user's logic cones after sweeping, synthesis and grafting.]

SideEffects []

SeeAlso []

Definition at line 1064 of file giaSweeper.c.

{
    Gia_Man_t * pNew;
    Vec_Int_t * vLits;
    int ProbeId, i;
    // sweeper is running
    assert( Gia_SweeperIsRunning(p) );
    // sweep the logic
    pNew = Gia_SweeperSweep( p, vProbeIds, nWords, nConfs, fVerify, fVerbose );
    if ( pNew == NULL )
        return 0;
    // execute command line
    if ( pCommLime )
    {
        // set pNew to be current GIA in ABC
        Abc_FrameUpdateGia( Abc_FrameGetGlobalFrame(), pNew );
        // execute command line pCommLine using Abc_CmdCommandExecute()
        Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), pCommLime );
        // get pNew to be current GIA in ABC     
        pNew = Abc_FrameGetGia( Abc_FrameGetGlobalFrame() );
    }
    // return logic back into the main manager
    vLits = Gia_SweeperGraft( p, NULL, pNew );
    Gia_ManStop( pNew );
    // update the array of probes
    Vec_IntForEachEntry( vProbeIds, ProbeId, i )
        Gia_SweeperProbeUpdate( p, ProbeId, Vec_IntEntry(vLits, i) );
    Vec_IntFree( vLits );        
    return 1;
}

Here is the call graph for this function:

◆ Gia_SweeperGetCex()

Vec_Int_t * Gia_SweeperGetCex ( Gia_Man_t * p )

extern

Definition at line 230 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    assert( pSwp->vCexUser == NULL || Vec_IntSize(pSwp->vCexUser) == Gia_ManPiNum(p) );
    return pSwp->vCexUser;
}

◆ Gia_SweeperGraft()

Vec_Int_t * Gia_SweeperGraft	(	Gia_Man_t *	pDst,
		Vec_Int_t *	vProbes,
		Gia_Man_t *	pSrc )

extern

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

Synopsis [Performs grafting from another manager.]

Description [Returns the array of resulting literals in the destination manager.]

SideEffects []

SeeAlso []

Definition at line 985 of file giaSweeper.c.

{
    Vec_Int_t * vOutLits;
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_SweeperIsRunning(pDst) );
    if ( vProbes )
        assert( Vec_IntSize(vProbes) == Gia_ManPiNum(pSrc) );
    else
        assert( Gia_ManPiNum(pDst) == Gia_ManPiNum(pSrc) );
    Gia_ManForEachPi( pSrc, pObj, i )
        pObj->Value = vProbes ? Gia_SweeperProbeLit(pDst, Vec_IntEntry(vProbes, i)) : Gia_Obj2Lit(pDst,Gia_ManPi(pDst, i));
    Gia_ManForEachAnd( pSrc, pObj, i )
        pObj->Value = Gia_ManHashAnd( pDst, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
    vOutLits = Vec_IntAlloc( Gia_ManPoNum(pSrc) );
    Gia_ManForEachPo( pSrc, pObj, i )
        Vec_IntPush( vOutLits, Gia_ObjFanin0Copy(pObj) );
    return vOutLits;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_SweeperIsRunning()

int Gia_SweeperIsRunning ( Gia_Man_t * p )

extern

Definition at line 164 of file giaSweeper.c.

{
    return (pGia->pData != NULL);
}

Here is the caller graph for this function:

◆ Gia_SweeperLogicDump()

void Gia_SweeperLogicDump	(	Gia_Man_t *	p,
		Vec_Int_t *	vProbeIds,
		int	fDumpConds,
		char *	pFileName )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 428 of file giaSweeper.c.

{
    Gia_Man_t * pGiaOuts = Gia_SweeperExtractUserLogic( p, vProbeIds, NULL, NULL );
    Vec_Int_t * vProbeConds = Gia_SweeperCondVector( p );
    printf( "Dumping logic cones" );
    if ( fDumpConds && Vec_IntSize(vProbeConds) > 0 )
    {
        Gia_Man_t * pGiaCond = Gia_SweeperExtractUserLogic( p, vProbeConds, NULL, NULL );
        Gia_ManDupAppendShare( pGiaOuts, pGiaCond );
        pGiaOuts->nConstrs = Gia_ManPoNum(pGiaCond);
        Gia_ManHashStop( pGiaOuts );
        Gia_ManStop( pGiaCond );
        printf( " and conditions" );
    }
    Gia_AigerWrite( pGiaOuts, pFileName, 0, 0, 0 );
    Gia_ManStop( pGiaOuts );
    printf( " into file \"%s\".\n", pFileName );
}

Here is the call graph for this function:

◆ Gia_SweeperPrintStats()

void Gia_SweeperPrintStats ( Gia_Man_t * p )

extern

Definition at line 181 of file giaSweeper.c.

{
    Swp_Man_t * p = (Swp_Man_t *)pGia->pData;
    double nMemSwp = Gia_SweeperMemUsage(pGia);
    double nMemGia = (double)Gia_ManObjNum(pGia)*(sizeof(Gia_Obj_t) + sizeof(int));
    double nMemSat = sat_solver_memory(p->pSat);
    double nMemTot = nMemSwp + nMemGia + nMemSat;
    printf( "SAT sweeper statistics:\n" );
    printf( "Memory usage:\n" );
    ABC_PRMP( "Sweeper         ", nMemSwp, nMemTot );
    ABC_PRMP( "AIG manager     ", nMemGia, nMemTot );
    ABC_PRMP( "SAT solver      ", nMemSat, nMemTot );
    ABC_PRMP( "TOTAL           ", nMemTot, nMemTot );
    printf( "Runtime usage:\n" );
    p->timeTotal = Abc_Clock() - p->timeStart;
    ABC_PRTP( "CNF construction", p->timeCnf,      p->timeTotal );
    ABC_PRTP( "SAT solving     ", p->timeSat,      p->timeTotal );
    ABC_PRTP( "    Sat         ", p->timeSatSat,   p->timeTotal );
    ABC_PRTP( "    Unsat       ", p->timeSatUnsat, p->timeTotal );
    ABC_PRTP( "    Undecided   ", p->timeSatUndec, p->timeTotal );
    ABC_PRTP( "TOTAL RUNTIME   ", p->timeTotal,    p->timeTotal );
    printf( "GIA: " );
    Gia_ManPrintStats( pGia, NULL );
    printf( "SAT calls = %d. Sat = %d. Unsat = %d. Undecided = %d.  Proofs = %d.\n", 
        p->nSatCalls, p->nSatCallsSat, p->nSatCallsUnsat, p->nSatCallsUndec, p->nSatProofs );
    Sat_SolverPrintStats( stdout, p->pSat );
}

Here is the call graph for this function:

◆ Gia_SweeperProbeCreate()

int Gia_SweeperProbeCreate	(	Gia_Man_t *	p,
		int	iLit )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 249 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    int ProbeId = Vec_IntSize(pSwp->vProbes);
    assert( iLit >= 0 );
    Vec_IntPush( pSwp->vProbes, iLit );
    return ProbeId;
}

Here is the caller graph for this function:

◆ Gia_SweeperProbeDelete()

int Gia_SweeperProbeDelete	(	Gia_Man_t *	p,
		int	ProbeId )

extern

Definition at line 258 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    int iLit = Vec_IntEntry(pSwp->vProbes, ProbeId);
    assert( iLit >= 0 );
    Vec_IntWriteEntry(pSwp->vProbes, ProbeId, -1);
    return iLit;
}

◆ Gia_SweeperProbeLit()

int Gia_SweeperProbeLit	(	Gia_Man_t *	p,
		int	ProbeId )

extern

Definition at line 276 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    int iLit = Vec_IntEntry(pSwp->vProbes, ProbeId);
    assert( iLit >= 0 );
    return iLit;
}

Here is the caller graph for this function:

◆ Gia_SweeperProbeUpdate()

int Gia_SweeperProbeUpdate	(	Gia_Man_t *	p,
		int	ProbeId,
		int	iLitNew )

extern

Definition at line 267 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    int iLit = Vec_IntEntry(pSwp->vProbes, ProbeId);
    assert( iLit >= 0 );
    Vec_IntWriteEntry(pSwp->vProbes, ProbeId, iLitNew);
    return iLit;
}

Here is the caller graph for this function:

◆ Gia_SweeperRun()

int Gia_SweeperRun	(	Gia_Man_t *	p,
		Vec_Int_t *	vProbeIds,
		char *	pCommLime,
		int	fVerbose )

extern

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

Synopsis [Executes given command line for the logic defined by the probes.]

Description [ ]

SideEffects []

SeeAlso []

Definition at line 1106 of file giaSweeper.c.

{
    Gia_Man_t * pNew;
    Vec_Int_t * vLits;
    int ProbeId, i;
    // sweeper is running
    assert( Gia_SweeperIsRunning(p) );
    // sweep the logic
    pNew = Gia_SweeperExtractUserLogic( p, vProbeIds, NULL, NULL );
    // execute command line
    if ( pCommLime )
    {
        if ( fVerbose )
            printf( "GIA manager statistics before and after applying \"%s\":\n", pCommLime );
        if ( fVerbose )
            Gia_ManPrintStats( pNew, NULL );
        // set pNew to be current GIA in ABC
        Abc_FrameUpdateGia( Abc_FrameGetGlobalFrame(), pNew );
        // execute command line pCommLine using Abc_CmdCommandExecute()
        Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), pCommLime );
        // get pNew to be current GIA in ABC     
        pNew = Abc_FrameGetGia( Abc_FrameGetGlobalFrame() );
        if ( fVerbose )
            Gia_ManPrintStats( pNew, NULL );
    }
    // return logic back into the main manager
    vLits = Gia_SweeperGraft( p, NULL, pNew );
    Gia_ManStop( pNew );
    // update the array of probes
    Vec_IntForEachEntry( vProbeIds, ProbeId, i )
        Gia_SweeperProbeUpdate( p, ProbeId, Vec_IntEntry(vLits, i) );
    Vec_IntFree( vLits );        
    return 1;
}

Here is the call graph for this function:

◆ Gia_SweeperSetConflictLimit()

void Gia_SweeperSetConflictLimit	(	Gia_Man_t *	p,
		int	nConfMax )

extern

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

Synopsis [Setting resource limits.]

Description []

SideEffects []

SeeAlso []

Definition at line 220 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    pSwp->nConfMax = nConfMax;
}

◆ Gia_SweeperSetRuntimeLimit()

void Gia_SweeperSetRuntimeLimit	(	Gia_Man_t *	p,
		int	nSeconds )

extern

Definition at line 225 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    pSwp->nTimeOut = nSeconds;
}

◆ Gia_SweeperStart()

Gia_Man_t * Gia_SweeperStart ( Gia_Man_t * p )

extern

Definition at line 145 of file giaSweeper.c.

{
    if ( pGia == NULL )
        pGia = Gia_ManStart( 10000 );
    if ( Vec_IntSize(&pGia->vHTable) == 0 )
        Gia_ManHashStart( pGia );
    // recompute fPhase and fMark1 to mark multiple fanout nodes if AIG is already defined!!!
 
    Swp_ManStart( pGia );
    pGia->fSweeper = 1;
    return pGia;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_SweeperStop()

void Gia_SweeperStop ( Gia_Man_t * p )

extern

Definition at line 157 of file giaSweeper.c.

{
    pGia->fSweeper = 0;
    Swp_ManStop( pGia );
    Gia_ManHashStop( pGia );
//    Gia_ManStop( pGia );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Gia_TimeStamp()

char * Gia_TimeStamp ( )

extern

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:

◆ Jf_ManDeriveCnf()

Gia_Man_t * Jf_ManDeriveCnf	(	Gia_Man_t *	p,
		int	fCnfObjIds )

extern

Definition at line 1749 of file giaJf.c.

{
    Jf_Par_t Pars, * pPars = &Pars;
    Jf_ManSetDefaultPars( pPars );
    pPars->fGenCnf = 1;
    pPars->fCnfObjIds = fCnfObjIds;
    return Jf_ManPerformMapping( p, pPars );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Jf_ManPerformMapping()

Gia_Man_t * Jf_ManPerformMapping	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars )

extern

Definition at line 1715 of file giaJf.c.

{
    Gia_Man_t * pNew = pGia;
    Jf_Man_t * p; int i;
    assert( !Gia_ManBufNum(pGia) );
    assert( !pPars->fCutMin || !pPars->fFuncDsd || pPars->nLutSize <= 6 );
    if ( pPars->fGenCnf )
        pPars->fCutMin = 1, pPars->fFuncDsd = 1, pPars->fOptEdge = 0;
    if ( pPars->fCutMin && !pPars->fFuncDsd )
        pPars->fCoarsen = 0;
    p = Jf_ManAlloc( pGia, pPars );
    p->pCutCmp = pPars->fAreaOnly ? Jf_CutCompareArea : Jf_CutCompareDelay;
    Jf_ManComputeCuts( p, 0 );
    Jf_ManComputeRefs( p );                         Jf_ManPrintStats( p, "Start" );
    for ( i = 0; i < pPars->nRounds; i++ )
    {
        if ( !p->pPars->fGenCnf )
        {
        Jf_ManPropagateFlow( p, pPars->fOptEdge );  Jf_ManPrintStats( p, "Flow " );
        }
        Jf_ManPropagateEla( p, 0 );                 Jf_ManPrintStats( p, "Area " );
        Jf_ManPropagateEla( p, 1 );                 Jf_ManPrintStats( p, "Edge " );
    }
    if ( p->pPars->fVeryVerbose && p->pPars->fCutMin && !p->pPars->fFuncDsd )
        Vec_MemDumpTruthTables( p->vTtMem, Gia_ManName(p->pGia), p->pPars->nLutSize );
    if ( p->pPars->fPureAig )
        pNew = Jf_ManDeriveGia(p);
    else if ( p->pPars->fCutMin )
        pNew = Jf_ManDeriveMappingGia(p);
    else
        Jf_ManDeriveMapping(p);
    Jf_ManFree( p );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Jf_ManSetDefaultPars()

void Jf_ManSetDefaultPars ( Jf_Par_t * pPars )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1682 of file giaJf.c.

{
    memset( pPars, 0, sizeof(Jf_Par_t) );
    pPars->nLutSize     =  6;
    pPars->nCutNum      =  8;
    pPars->nRounds      =  1;
    pPars->nVerbLimit   =  5;
    pPars->DelayTarget  = -1;
    pPars->fAreaOnly    =  1;
    pPars->fOptEdge     =  1; 
    pPars->fCoarsen     =  0;
    pPars->fCutMin      =  0;
    pPars->fFuncDsd     =  0;
    pPars->fGenCnf      =  0;
    pPars->fPureAig     =  0;
    pPars->fVerbose     =  0;
    pPars->fVeryVerbose =  0;
    pPars->nLutSizeMax  =  JF_LEAF_MAX;
    pPars->nCutNumMax   =  JF_CUT_MAX;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManPerformMapping()

Gia_Man_t * Lf_ManPerformMapping	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars )

extern

Definition at line 2242 of file giaLf.c.

{
    Gia_Man_t * pNew;
    if ( p->pManTime && Tim_ManBoxNum((Tim_Man_t*)p->pManTime) && Gia_ManIsNormalized(p) )
    {
        Tim_Man_t * pTimOld = (Tim_Man_t *)p->pManTime;
        p->pManTime = Tim_ManDup( pTimOld, 1 );
        pNew = Gia_ManDupUnnormalize( p );
        if ( pNew == NULL )
            return NULL;
        Gia_ManTransferTiming( pNew, p );
        p = pNew;
        // mapping
        pNew = Lf_ManPerformMappingInt( p, pPars );
        if ( pNew != p )
        {
            Gia_ManTransferTiming( pNew, p );
            Gia_ManStop( p );
        }
        // normalize
        pNew = Gia_ManDupNormalize( p = pNew, 0 );
        Gia_ManTransferMapping( pNew, p );
//        Gia_ManTransferPacking( pNew, p );
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p ); // do not delete if the original one!
        // cleanup
        Tim_ManStop( (Tim_Man_t *)pNew->pManTime );
        pNew->pManTime = pTimOld;
        assert( Gia_ManIsNormalized(pNew) );
    }
    else 
    {
        // mapping
        pNew = Lf_ManPerformMappingInt( p, pPars );
        Gia_ManTransferTiming( pNew, p );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Lf_ManSetDefaultPars()

void Lf_ManSetDefaultPars ( Jf_Par_t * pPars )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2021 of file giaLf.c.

{
    memset( pPars, 0, sizeof(Jf_Par_t) );
    pPars->nLutSize     =  6;
    pPars->nCutNum      =  8;
    pPars->nProcNum     =  0;
    pPars->nRounds      =  4;
    pPars->nRoundsEla   =  1;
    pPars->nRelaxRatio  =  0;
    pPars->nCoarseLimit =  3;
    pPars->nAreaTuner   =  1;
    pPars->nVerbLimit   =  5;
    pPars->DelayTarget  = -1;
    pPars->fAreaOnly    =  0;
    pPars->fOptEdge     =  1; 
    pPars->fUseMux7     =  0;
    pPars->fPower       =  0;
    pPars->fCoarsen     =  1;
    pPars->fCutMin      =  0;
    pPars->fFuncDsd     =  0;
    pPars->fGenCnf      =  0;
    pPars->fPureAig     =  0;
    pPars->fCutHashing  =  0;
    pPars->fCutSimple   =  0;
    pPars->fVerbose     =  0;
    pPars->fVeryVerbose =  0;
    pPars->nLutSizeMax  =  LF_LEAF_MAX;
    pPars->nCutNumMax   =  LF_CUT_MAX;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Mf_ManGenerateCnf()

void * Mf_ManGenerateCnf	(	Gia_Man_t *	pGia,
		int	nLutSize,
		int	fCnfObjIds,
		int	fAddOrCla,
		int	fMapping,
		int	fVerbose )

extern

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

Synopsis [CNF generation]

Description []

SideEffects []

SeeAlso []

Definition at line 1877 of file giaMf.c.

{
    Gia_Man_t * pNew;
    Jf_Par_t Pars, * pPars = &Pars;
    assert( nLutSize >= 3 && nLutSize <= 8 );
    Mf_ManSetDefaultPars( pPars );
    pPars->fGenCnf     = 1;
    pPars->fCoarsen    = !fCnfObjIds;
    pPars->nLutSize    = nLutSize;
    pPars->fCnfObjIds  = fCnfObjIds;
    pPars->fAddOrCla   = fAddOrCla;
    pPars->fCnfMapping = fMapping;
    pPars->fVerbose    = fVerbose;
    pNew = Mf_ManPerformMapping( pGia, pPars );
    Gia_ManStopP( &pNew );
//    Cnf_DataPrint( (Cnf_Dat_t *)pGia->pData, 1 );
    return pGia->pData;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Mf_ManPerformMapping()

Gia_Man_t * Mf_ManPerformMapping	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars )

extern

Definition at line 1822 of file giaMf.c.

{
    Mf_Man_t * p;
    Gia_Man_t * pNew, * pCls;
    if ( pPars->fGenCnf || pPars->fGenLit )
        pPars->fCutMin = 1;
    if ( Gia_ManHasChoices(pGia) )
        pPars->fCutMin = 1, pPars->fCoarsen = 0; 
    pCls = pPars->fCoarsen ? Gia_ManDupMuxes(pGia, pPars->nCoarseLimit) : pGia;
    p = Mf_ManAlloc( pCls, pPars );
    p->pGia0 = pGia;
    if ( pPars->fVerbose && pPars->fCoarsen )
    {
        printf( "Initial " );  Gia_ManPrintMuxStats( pGia );  printf( "\n" );
        printf( "Derived " );  Gia_ManPrintMuxStats( pCls );  printf( "\n" );
    }
    Mf_ManPrintInit( p );
    Mf_ManComputeCuts( p );
    for ( p->Iter = 1; p->Iter < p->pPars->nRounds; p->Iter++ )
        Mf_ManComputeMapping( p );
    p->fUseEla = 1;
    for ( ; p->Iter < p->pPars->nRounds + pPars->nRoundsEla; p->Iter++ )
        Mf_ManComputeMapping( p );
    //Mf_ManOptimization( p );
    if ( pPars->fVeryVerbose && pPars->fCutMin )
        Vec_MemDumpTruthTables( p->vTtMem, Gia_ManName(p->pGia), pPars->nLutSize );
    if ( pPars->fCutMin )
        pNew = Mf_ManDeriveMappingGia( p );
    else if ( pPars->fCoarsen )
        pNew = Mf_ManDeriveMappingCoarse( p );
    else
        pNew = Mf_ManDeriveMapping( p );
    if ( p->pPars->fGenCnf )
        pGia->pData = Mf_ManDeriveCnf( p, p->pPars->fCnfObjIds, p->pPars->fAddOrCla );
    //if ( p->pPars->fGenCnf || p->pPars->fGenLit )
    //    Mf_ManProfileTruths( p );
    Gia_ManMappingVerify( pNew );
    Mf_ManPrintQuit( p, pNew );
    Mf_ManFree( p );
    if ( pCls != pGia )
        Gia_ManStop( pCls );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Mf_ManSetDefaultPars()

void Mf_ManSetDefaultPars ( Jf_Par_t * pPars )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1441 of file giaMf.c.

{
    memset( pPars, 0, sizeof(Jf_Par_t) );
    pPars->nLutSize     =  6;
    pPars->nCutNum      =  8;
    pPars->nProcNum     =  0;
    pPars->nRounds      =  2;
    pPars->nRoundsEla   =  1;
    pPars->nRelaxRatio  =  0;
    pPars->nCoarseLimit =  3;
    pPars->nAreaTuner   =  1;
    pPars->nVerbLimit   =  5;
    pPars->DelayTarget  = -1;
    pPars->fAreaOnly    =  0;
    pPars->fOptEdge     =  1; 
    pPars->fCoarsen     =  1;
    pPars->fCutMin      =  0;
    pPars->fGenCnf      =  0;
    pPars->fGenLit      =  0;
    pPars->fPureAig     =  0;
    pPars->fVerbose     =  0;
    pPars->fVeryVerbose =  0;
    pPars->nLutSizeMax  =  MF_LEAF_MAX;
    pPars->nCutNumMax   =  MF_CUT_MAX;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Sat_ManTest()

int Sat_ManTest	(	Gia_Man_t *	pGia,
		Gia_Obj_t *	pObj,
		int	nConfsMax )

extern

◆ Tas_ManAlloc()

Tas_Man_t * Tas_ManAlloc	(	Gia_Man_t *	pAig,
		int	nBTLimit )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 187 of file giaCTas.c.

{
    Tas_Man_t * p;
    p = ABC_CALLOC( Tas_Man_t, 1 );
    Tas_SetDefaultParams( &p->Pars );
    p->pAig           = pAig;
    p->Pars.nBTLimit  = nBTLimit;
    p->pProp.nSize    = p->pJust.nSize = p->pClauses.nSize = 10000;
    p->pProp.pData    = ABC_ALLOC( Gia_Obj_t *, p->pProp.nSize );
    p->pJust.pData    = ABC_ALLOC( Gia_Obj_t *, p->pJust.nSize );
    p->pClauses.pData = ABC_ALLOC( Gia_Obj_t *, p->pClauses.nSize );
    p->pClauses.iHead = p->pClauses.iTail = 1;
    p->vModel         = Vec_IntAlloc( 1000 );
    p->vLevReas       = Vec_IntAlloc( 1000 );
    p->vTemp          = Vec_PtrAlloc( 1000 );
    p->pStore.iCur    = 16;
    p->pStore.nSize   = 10000;
    p->pStore.pData   = ABC_ALLOC( int, p->pStore.nSize );
    p->pWatches       = ABC_CALLOC( int, 2 * Gia_ManObjNum(pAig) );
    p->vWatchLits     = Vec_IntAlloc( 100 );
    p->pActivity      = ABC_CALLOC( float, Gia_ManObjNum(pAig) );
    p->vActiveVars    = Vec_IntAlloc( 100 );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Tas_ManSatPrintStats()

void Tas_ManSatPrintStats ( Tas_Man_t * p )

extern

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

Synopsis [Prints statistics of the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 1487 of file giaCTas.c.

{
    printf( "CO = %8d  ", Gia_ManCoNum(p->pAig) );
    printf( "AND = %8d  ", Gia_ManAndNum(p->pAig) );
    printf( "Conf = %6d  ", p->Pars.nBTLimit );
    printf( "JustMax = %5d  ", p->Pars.nJustLimit );
    printf( "\n" );
    printf( "Unsat calls %6d  (%6.2f %%)   Ave conf = %8.1f   ", 
        p->nSatUnsat, p->nSatTotal? 100.0*p->nSatUnsat/p->nSatTotal :0.0, p->nSatUnsat? 1.0*p->nConfUnsat/p->nSatUnsat :0.0 );
    ABC_PRTP( "Time", p->timeSatUnsat, p->timeTotal );
    printf( "Sat   calls %6d  (%6.2f %%)   Ave conf = %8.1f   ", 
        p->nSatSat,   p->nSatTotal? 100.0*p->nSatSat/p->nSatTotal :0.0, p->nSatSat? 1.0*p->nConfSat/p->nSatSat : 0.0 );
    ABC_PRTP( "Time", p->timeSatSat,   p->timeTotal );
    printf( "Undef calls %6d  (%6.2f %%)   Ave conf = %8.1f   ", 
        p->nSatUndec, p->nSatTotal? 100.0*p->nSatUndec/p->nSatTotal :0.0, p->nSatUndec? 1.0*p->nConfUndec/p->nSatUndec : 0.0 );
    ABC_PRTP( "Time", p->timeSatUndec, p->timeTotal );
    ABC_PRT( "Total time", p->timeTotal );
}

Here is the caller graph for this function:

◆ Tas_ManSolve()

int Tas_ManSolve	(	Tas_Man_t *	p,
		Gia_Obj_t *	pObj,
		Gia_Obj_t *	pObj2 )

extern

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

Synopsis [Looking for a satisfying assignment of the node.]

Description [Assumes that each node has flag pObj->fMark0 set to 0. Returns 1 if unsatisfiable, 0 if satisfiable, and -1 if undecided. The node may be complemented. ]

SideEffects []

SeeAlso []

Definition at line 1366 of file giaCTas.c.

{
    int i, Entry, RetValue = 0;
    s_Counter2 = 0;
    Vec_IntClear( p->vModel );
    if ( pObj == Gia_ManConst0(p->pAig) || pObj2 == Gia_ManConst0(p->pAig) || pObj == Gia_Not(pObj2) )
        return 1;
    if ( pObj == Gia_ManConst1(p->pAig) && (pObj2 == NULL || pObj2 == Gia_ManConst1(p->pAig)) )
        return 0;
    assert( !p->pProp.iHead && !p->pProp.iTail );
    assert( !p->pJust.iHead && !p->pJust.iTail );
    assert( p->pClauses.iHead == 1 && p->pClauses.iTail == 1 );
    p->Pars.nBTThis = p->Pars.nJustThis = p->Pars.nBTThisNc = 0;
    Tas_ManAssign( p, pObj, 0, NULL, NULL );
    if ( pObj2 && !Tas_VarIsAssigned(Gia_Regular(pObj2)) )
        Tas_ManAssign( p, pObj2, 0, NULL, NULL );
    if ( !Tas_ManSolve_rec(p, 0) && !Tas_ManCheckLimits(p) )
        Tas_ManSaveModel( p, p->vModel );
    else
        RetValue = 1;
    Tas_ManCancelUntil( p, 0 );
    p->pJust.iHead = p->pJust.iTail = 0;
    p->pClauses.iHead = p->pClauses.iTail = 1;
    // clauses
    if ( p->nClauses > 0 )
    {
        p->pStore.iCur = 16;
        Vec_IntForEachEntry( p->vWatchLits, Entry, i )
            p->pWatches[Entry] = 0;
        Vec_IntClear( p->vWatchLits );
        p->nClauses = 0;
    }
    // activity
    Vec_IntForEachEntry( p->vActiveVars, Entry, i )
        p->pActivity[Entry] = 0.0;
    Vec_IntClear( p->vActiveVars );
    // statistics
    p->Pars.nBTTotal += p->Pars.nBTThis;
    p->Pars.nJustTotal = Abc_MaxInt( p->Pars.nJustTotal, p->Pars.nJustThis );
    if ( Tas_ManCheckLimits( p ) )
        RetValue = -1;
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Tas_ManSolveArray()

int Tas_ManSolveArray	(	Tas_Man_t *	p,
		Vec_Ptr_t *	vObjs )

extern

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

Synopsis [Looking for a satisfying assignment of the node.]

Description [Assumes that each node has flag pObj->fMark0 set to 0. Returns 1 if unsatisfiable, 0 if satisfiable, and -1 if undecided. The node may be complemented. ]

SideEffects []

SeeAlso []

Definition at line 1423 of file giaCTas.c.

{
    Gia_Obj_t * pObj;
    int i, Entry, RetValue = 0;
    s_Counter2 = 0;
    s_Counter3 = 0;
    s_Counter4 = 0;
    Vec_IntClear( p->vModel );
    Vec_PtrForEachEntry( Gia_Obj_t *, vObjs, pObj, i )
        if ( pObj == Gia_ManConst0(p->pAig) )
            return 1;
    assert( !p->pProp.iHead && !p->pProp.iTail );
    assert( !p->pJust.iHead && !p->pJust.iTail );
    assert( p->pClauses.iHead == 1 && p->pClauses.iTail == 1 );
    p->Pars.nBTThis = p->Pars.nJustThis = p->Pars.nBTThisNc = 0;
    Vec_PtrForEachEntry( Gia_Obj_t *, vObjs, pObj, i )
        if ( pObj != Gia_ManConst1(p->pAig) && !Tas_VarIsAssigned(Gia_Regular(pObj)) )
            Tas_ManAssign( p, pObj, 0, NULL, NULL );
    if ( !Tas_ManSolve_rec(p, 0) && !Tas_ManCheckLimits(p) )
        Tas_ManSaveModel( p, p->vModel );
    else
        RetValue = 1;
    Tas_ManCancelUntil( p, 0 );
    p->pJust.iHead = p->pJust.iTail = 0;
    p->pClauses.iHead = p->pClauses.iTail = 1;
    // clauses
    if ( p->nClauses > 0 )
    {
        p->pStore.iCur = 16;
        Vec_IntForEachEntry( p->vWatchLits, Entry, i )
            p->pWatches[Entry] = 0;
        Vec_IntClear( p->vWatchLits );
        p->nClauses = 0;
    }
    // activity
    Vec_IntForEachEntry( p->vActiveVars, Entry, i )
        p->pActivity[Entry] = 0.0;
    Vec_IntClear( p->vActiveVars );
    // statistics
    p->Pars.nBTTotal += p->Pars.nBTThis;
    p->Pars.nJustTotal = Abc_MaxInt( p->Pars.nJustTotal, p->Pars.nJustThis );
    if ( Tas_ManCheckLimits( p ) )
        RetValue = -1;
 
//    printf( "%d ", Gia_ManObjNum(p->pAig) );
//    printf( "%d ", p->Pars.nBTThis );
//    printf( "%d ", p->Pars.nJustThis );
//    printf( "%d ", s_Counter2 );
//    printf( "%d ", s_Counter3 );
//    printf( "%d  ", s_Counter4 );
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Tas_ManSolveMiterNc()

Vec_Int_t * Tas_ManSolveMiterNc	(	Gia_Man_t *	pAig,
		int	nConfs,
		Vec_Str_t **	pvStatus,
		int	fVerbose )

extern

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

Synopsis [Procedure to test the new SAT solver.]

Description []

SideEffects []

SeeAlso []

Definition at line 1517 of file giaCTas.c.

{
    extern void Gia_ManCollectTest( Gia_Man_t * pAig );
    extern void Cec_ManSatAddToStore( Vec_Int_t * vCexStore, Vec_Int_t * vCex, int Out );
    Tas_Man_t * p; 
    Vec_Int_t * vCex, * vVisit, * vCexStore;
    Vec_Str_t * vStatus;
    Gia_Obj_t * pRoot;//, * pRootCopy; 
//    Gia_Man_t * pAigCopy = Gia_ManDup( pAig ), * pAigTemp;
 
    int i, status;
    abctime clk, clkTotal = Abc_Clock();
    assert( Gia_ManRegNum(pAig) == 0 );
//    Gia_ManCollectTest( pAig );
    // prepare AIG
    Gia_ManCreateRefs( pAig );
    Gia_ManCleanMark0( pAig );
    Gia_ManCleanMark1( pAig );
    Gia_ManFillValue( pAig ); // maps nodes into trail ids
    Gia_ManCleanPhase( pAig ); // maps nodes into trail ids
    // create logic network
    p = Tas_ManAlloc( pAig, nConfs );
    p->pAig   = pAig;
    // create resulting data-structures
    vStatus   = Vec_StrAlloc( Gia_ManPoNum(pAig) );
    vCexStore = Vec_IntAlloc( 10000 );
    vVisit    = Vec_IntAlloc( 100 );
    vCex      = Tas_ReadModel( p );
    // solve for each output
    Gia_ManForEachCo( pAig, pRoot, i )
    {
//        printf( "%d=", i );
 
        Vec_IntClear( vCex );
        if ( Gia_ObjIsConst0(Gia_ObjFanin0(pRoot)) )
        {
            if ( Gia_ObjFaninC0(pRoot) )
            {
//                printf( "Constant 1 output of SRM!!!\n" );
                Cec_ManSatAddToStore( vCexStore, vCex, i ); // trivial counter-example
                Vec_StrPush( vStatus, 0 );
            }
            else
            {
//                printf( "Constant 0 output of SRM!!!\n" );
                Vec_StrPush( vStatus, 1 );
            }
            continue;
        } 
        clk = Abc_Clock();
//        p->Pars.fUseActive  = 1;
        p->Pars.fUseHighest = 1;
        p->Pars.fUseLowest  = 0;
        status = Tas_ManSolve( p, Gia_ObjChild0(pRoot), NULL );
//        printf( "\n" );
/*
        if ( status == -1 )
        {
            p->Pars.fUseHighest = 0;
            p->Pars.fUseLowest  = 1;
            status = Tas_ManSolve( p, Gia_ObjChild0(pRoot) );
        }
*/
        Vec_StrPush( vStatus, (char)status );
        if ( status == -1 )
        {
//            printf( "Unsolved %d.\n", i );
 
            p->nSatUndec++;
            p->nConfUndec += p->Pars.nBTThis;
            Cec_ManSatAddToStore( vCexStore, NULL, i ); // timeout
            p->timeSatUndec += Abc_Clock() - clk;
            continue;
        }
 
//        pRootCopy = Gia_ManCo( pAigCopy, i );
//        pRootCopy->iDiff0 = Gia_ObjId( pAigCopy, pRootCopy );
//        pRootCopy->fCompl0 = 0;
 
        if ( status == 1 )
        {
            p->nSatUnsat++;
            p->nConfUnsat += p->Pars.nBTThis;
            p->timeSatUnsat += Abc_Clock() - clk;
            continue;
        }
        p->nSatSat++;
        p->nConfSat += p->Pars.nBTThis;
//        Gia_SatVerifyPattern( pAig, pRoot, vCex, vVisit );
        Cec_ManSatAddToStore( vCexStore, vCex, i );
        p->timeSatSat += Abc_Clock() - clk;
 
//        printf( "%d ", Vec_IntSize(vCex) );
    }
//    pAigCopy = Gia_ManCleanup( pAigTemp = pAigCopy );
//    Gia_ManStop( pAigTemp );
//    Gia_DumpAiger( pAigCopy, "test", 0, 2 );
//    Gia_ManStop( pAigCopy );
 
    Vec_IntFree( vVisit );
    p->nSatTotal = Gia_ManPoNum(pAig);
    p->timeTotal = Abc_Clock() - clkTotal;
    if ( fVerbose )
        Tas_ManSatPrintStats( p );
//    printf( "RecCalls = %8d.  RecClause = %8d.  RecNonChro = %8d.\n", p->nRecCall, p->nRecClause, p->nRecNonChro );
    Tas_ManStop( p );
    *pvStatus = vStatus;
 
//    printf( "Total number of cex literals = %d. (Ave = %d)\n", 
//         Vec_IntSize(vCexStore)-2*p->nSatUndec-2*p->nSatSat, 
//        (Vec_IntSize(vCexStore)-2*p->nSatUndec-2*p->nSatSat)/p->nSatSat );
    return vCexStore;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Tas_ManStop()

void Tas_ManStop ( Tas_Man_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 223 of file giaCTas.c.

{
    Vec_IntFree( p->vActiveVars );
    Vec_IntFree( p->vWatchLits );
    Vec_IntFree( p->vLevReas );
    Vec_IntFree( p->vModel );
    Vec_PtrFree( p->vTemp );
    ABC_FREE( p->pActivity );
    ABC_FREE( p->pWatches );
    ABC_FREE( p->pStore.pData );
    ABC_FREE( p->pClauses.pData );
    ABC_FREE( p->pProp.pData );
    ABC_FREE( p->pJust.pData );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Tas_ReadModel()

Vec_Int_t * Tas_ReadModel ( Tas_Man_t * p )

extern

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

Synopsis [Returns satisfying assignment.]

Description []

SideEffects []

SeeAlso []

Definition at line 250 of file giaCTas.c.

{
    return p->vModel;
}

Here is the caller graph for this function:

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ Gia_CellForEachFanin

◆ Gia_ClassForEachObj

◆ Gia_ClassForEachObj1

◆ Gia_ClassForEachObjStart

◆ Gia_LutForEachFanin

◆ Gia_LutForEachFanin2

◆ Gia_LutForEachFaninIndex

◆ Gia_LutForEachFaninObj

◆ Gia_LutForEachFanout2

◆ Gia_ManForEachAnd

◆ Gia_ManForEachAndId

◆ Gia_ManForEachAndReverse

◆ Gia_ManForEachAndReverseId

◆ Gia_ManForEachBuf

◆ Gia_ManForEachBufId

◆ Gia_ManForEachCand

◆ Gia_ManForEachCell

◆ Gia_ManForEachCi

◆ Gia_ManForEachCiId

◆ Gia_ManForEachCiIdWithBoxes

◆ Gia_ManForEachCiReverse

◆ Gia_ManForEachCiVec

◆ Gia_ManForEachClass

◆ Gia_ManForEachClass0

◆ Gia_ManForEachClassReverse

◆ Gia_ManForEachCo

◆ Gia_ManForEachCoDriver

◆ Gia_ManForEachCoDriverId

◆ Gia_ManForEachCoId

◆ Gia_ManForEachConst

◆ Gia_ManForEachCoReverse

◆ Gia_ManForEachCoVec

◆ Gia_ManForEachCoWithBoxes

◆ Gia_ManForEachLut

◆ Gia_ManForEachLut2

◆ Gia_ManForEachLut2Reverse

◆ Gia_ManForEachLut2Vec

◆ Gia_ManForEachLut2VecReverse

◆ Gia_ManForEachLutReverse

◆ Gia_ManForEachMux

◆ Gia_ManForEachMuxId

◆ Gia_ManForEachObj

◆ Gia_ManForEachObj1

◆ Gia_ManForEachObjReverse

◆ Gia_ManForEachObjReverse1

◆ Gia_ManForEachObjReverseWithBoxes

◆ Gia_ManForEachObjVec

◆ Gia_ManForEachObjVecLit

◆ Gia_ManForEachObjVecReverse

◆ Gia_ManForEachObjVecStart

◆ Gia_ManForEachObjVecStartStop

◆ Gia_ManForEachObjVecStop

◆ Gia_ManForEachObjWithBoxes

◆ Gia_ManForEachPi

◆ Gia_ManForEachPo

◆ Gia_ManForEachRi

◆ Gia_ManForEachRiRo

◆ Gia_ManForEachRo

◆ Gia_ManForEachRoToRiVec

◆ GIA_NONE

◆ Gia_ObjForEachFanoutStatic

◆ Gia_ObjForEachFanoutStaticId

◆ Gia_ObjForEachFanoutStaticIndex

◆ GIA_ONE

◆ GIA_UND

◆ GIA_VOID

◆ GIA_ZER

Typedef Documentation

◆ Bnd_Man_t

◆ Cbs_Man_t

◆ Emb_Par_t

◆ Gia_ChMan_t

◆ Gia_Dat_t

◆ Gia_Man2Min_t

◆ Gia_Man_t