gia.h File Reference

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

Go to the source code of this file.

Data Structures
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 ///. More...
#define	GIA_VOID   0x0FFFFFFF
#define	GIA_ZER   1
#define	GIA_ONE   2
#define	GIA_UND   3
#define	Gia_ManForEachConst(p, i)   for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsConst(p, i) ) {} else
#define	Gia_ManForEachClass(p, i)   for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else
#define	Gia_ManForEachClassReverse(p, i)   for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsHead(p, i) ) {} else
#define	Gia_ClassForEachObj(p, i, iObj)   for ( assert(Gia_ObjIsHead(p, i)), iObj = i; iObj; iObj = Gia_ObjNext(p, iObj) )
#define	Gia_ClassForEachObj1(p, i, iObj)   for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, i); iObj; iObj = Gia_ObjNext(p, iObj) )
#define	Gia_ObjForEachFanoutStatic(p, pObj, pFanout, i)   for ( i = 0; (i < Gia_ObjFanoutNum(p, pObj)) && (((pFanout) = Gia_ObjFanout(p, pObj, i)), 1); i++ )
#define	Gia_ObjForEachFanoutStaticId(p, Id, FanId, i)   for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && (((FanId) = Gia_ObjFanoutId(p, Id, i)), 1); i++ )
#define	Gia_ManForEachLut(p, i)   for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut(p, i) ) {} else
#define	Gia_LutForEachFanin(p, i, iFan, k)   for ( k = 0; k < Gia_ObjLutSize(p,i) && ((iFan = Gia_ObjLutFanins(p,i)[k]),1); k++ )
#define	Gia_LutForEachFaninObj(p, i, pFanin, k)   for ( k = 0; k < Gia_ObjLutSize(p,i) && ((pFanin = Gia_ManObj(p, Gia_ObjLutFanins(p,i)[k])),1); k++ )
#define	Gia_ManForEachCell(p, i)   for ( i = 2; i < 2*Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsCell(p, i) ) {} else
#define	Gia_CellForEachFanin(p, i, iFanLit, k)   for ( k = 0; k < Gia_ObjCellSize(p,i) && ((iFanLit = Gia_ObjCellFanins(p,i)[k]),1); k++ )
#define	Gia_ManForEachObj(p, pObj, i)   for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )
	MACRO DEFINITIONS ///. More...
#define	Gia_ManForEachObj1(p, pObj, i)   for ( i = 1; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )
#define	Gia_ManForEachObjVec(vVec, p, pObj, i)   for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )
#define	Gia_ManForEachObjVecReverse(vVec, p, pObj, i)   for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i-- )
#define	Gia_ManForEachObjVecLit(vVec, p, pObj, fCompl, i)   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++ )
#define	Gia_ManForEachObjReverse(p, pObj, i)   for ( i = p->nObjs - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, i)); i-- )
#define	Gia_ManForEachObjReverse1(p, pObj, i)   for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- )
#define	Gia_ManForEachBuf(p, pObj, i)   for ( i = Gia_ManBufNum(p) ? 0 : p->nObjs; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsBuf(pObj) ) {} else
#define	Gia_ManForEachBufId(p, i)   for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsBuf(Gia_ManObj(p, i)) ) {} else
#define	Gia_ManForEachAnd(p, pObj, i)   for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsAnd(pObj) ) {} else
#define	Gia_ManForEachAndId(p, i)   for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else
#define	Gia_ManForEachMuxId(p, i)   for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else
#define	Gia_ManForEachCand(p, pObj, i)   for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsCand(pObj) ) {} else
#define	Gia_ManForEachAndReverse(p, pObj, i)   for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- ) if ( !Gia_ObjIsAnd(pObj) ) {} else
#define	Gia_ManForEachAndReverseId(p, i)   for ( i = p->nObjs - 1; (i > 0); i-- ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else
#define	Gia_ManForEachMux(p, pObj, i)   for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else
#define	Gia_ManForEachCi(p, pObj, i)   for ( i = 0; (i < Vec_IntSize(p->vCis)) && ((pObj) = Gia_ManCi(p, i)); i++ )
#define	Gia_ManForEachCiId(p, Id, i)   for ( i = 0; (i < Vec_IntSize(p->vCis)) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )
#define	Gia_ManForEachCiReverse(p, pObj, i)   for ( i = Vec_IntSize(p->vCis) - 1; (i >= 0) && ((pObj) = Gia_ManCi(p, i)); i-- )
#define	Gia_ManForEachCo(p, pObj, i)   for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ManCo(p, i)); i++ )
#define	Gia_ManForEachCoVec(vVec, p, pObj, i)   for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManCo(p, Vec_IntEntry(vVec,i))); i++ )
#define	Gia_ManForEachCoId(p, Id, i)   for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((Id) = Gia_ObjId(p, Gia_ManCo(p, i))); i++ )
#define	Gia_ManForEachCoReverse(p, pObj, i)   for ( i = Vec_IntSize(p->vCos) - 1; (i >= 0) && ((pObj) = Gia_ManCo(p, i)); i-- )
#define	Gia_ManForEachCoDriver(p, pObj, i)   for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ObjFanin0(Gia_ManCo(p, i))); i++ )
#define	Gia_ManForEachCoDriverId(p, DriverId, i)   for ( i = 0; (i < Vec_IntSize(p->vCos)) && (((DriverId) = Gia_ObjFaninId0p(p, Gia_ManCo(p, i))), 1); i++ )
#define	Gia_ManForEachPi(p, pObj, i)   for ( i = 0; (i < Gia_ManPiNum(p)) && ((pObj) = Gia_ManCi(p, i)); i++ )
#define	Gia_ManForEachPo(p, pObj, i)   for ( i = 0; (i < Gia_ManPoNum(p)) && ((pObj) = Gia_ManCo(p, i)); i++ )
#define	Gia_ManForEachRo(p, pObj, i)   for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )
#define	Gia_ManForEachRi(p, pObj, i)   for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCo(p, Gia_ManPoNum(p)+i)); i++ )
#define	Gia_ManForEachRiRo(p, pObjRi, pObjRo, i)   for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObjRi) = Gia_ManCo(p, Gia_ManPoNum(p)+i)) && ((pObjRo) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )

Typedefs
typedef struct Gia_MmFixed_t_	Gia_MmFixed_t
	BASIC TYPES ///. More...
typedef struct Gia_MmFlex_t_	Gia_MmFlex_t
typedef struct Gia_MmStep_t_	Gia_MmStep_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 Tas_Man_t_	Tas_Man_t

Functions
static unsigned	Gia_ObjCutSign (unsigned ObjId)
static int	Gia_WordHasOneBit (unsigned uWord)
static int	Gia_WordHasOnePair (unsigned uWord)
static int	Gia_WordCountOnes (unsigned uWord)
static int	Gia_WordFindFirstBit (unsigned uWord)
static int	Gia_ManTruthIsConst0 (unsigned *pIn, int nVars)
static int	Gia_ManTruthIsConst1 (unsigned *pIn, int nVars)
static void	Gia_ManTruthCopy (unsigned *pOut, unsigned *pIn, int nVars)
static void	Gia_ManTruthClear (unsigned *pOut, int nVars)
static void	Gia_ManTruthFill (unsigned *pOut, int nVars)
static void	Gia_ManTruthNot (unsigned *pOut, unsigned *pIn, int nVars)
static int	Gia_ManConst0Lit ()
static int	Gia_ManConst1Lit ()
static int	Gia_ManIsConst0Lit (int iLit)
static int	Gia_ManIsConst1Lit (int iLit)
static int	Gia_ManIsConstLit (int iLit)
static Gia_Obj_t *	Gia_Regular (Gia_Obj_t *p)
static Gia_Obj_t *	Gia_Not (Gia_Obj_t *p)
static Gia_Obj_t *	Gia_NotCond (Gia_Obj_t *p, int c)
static int	Gia_IsComplement (Gia_Obj_t *p)
static char *	Gia_ManName (Gia_Man_t *p)
static int	Gia_ManCiNum (Gia_Man_t *p)
static int	Gia_ManCoNum (Gia_Man_t *p)
static int	Gia_ManPiNum (Gia_Man_t *p)
static int	Gia_ManPoNum (Gia_Man_t *p)
static int	Gia_ManRegNum (Gia_Man_t *p)
static int	Gia_ManObjNum (Gia_Man_t *p)
static int	Gia_ManAndNum (Gia_Man_t *p)
static int	Gia_ManXorNum (Gia_Man_t *p)
static int	Gia_ManMuxNum (Gia_Man_t *p)
static int	Gia_ManBufNum (Gia_Man_t *p)
static int	Gia_ManAndNotBufNum (Gia_Man_t *p)
static int	Gia_ManCandNum (Gia_Man_t *p)
static int	Gia_ManConstrNum (Gia_Man_t *p)
static void	Gia_ManFlipVerbose (Gia_Man_t *p)
static int	Gia_ManHasChoices (Gia_Man_t *p)
static int	Gia_ManChoiceNum (Gia_Man_t *p)
static Gia_Obj_t *	Gia_ManConst0 (Gia_Man_t *p)
static Gia_Obj_t *	Gia_ManConst1 (Gia_Man_t *p)
static Gia_Obj_t *	Gia_ManObj (Gia_Man_t *p, int v)
static Gia_Obj_t *	Gia_ManCi (Gia_Man_t *p, int v)
static Gia_Obj_t *	Gia_ManCo (Gia_Man_t *p, int v)
static Gia_Obj_t *	Gia_ManPi (Gia_Man_t *p, int v)
static Gia_Obj_t *	Gia_ManPo (Gia_Man_t *p, int v)
static Gia_Obj_t *	Gia_ManRo (Gia_Man_t *p, int v)
static Gia_Obj_t *	Gia_ManRi (Gia_Man_t *p, int v)
static int	Gia_ObjId (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjCioId (Gia_Obj_t *pObj)
static void	Gia_ObjSetCioId (Gia_Obj_t *pObj, int v)
static int	Gia_ObjValue (Gia_Obj_t *pObj)
static void	Gia_ObjSetValue (Gia_Obj_t *pObj, int i)
static int	Gia_ObjPhase (Gia_Obj_t *pObj)
static int	Gia_ObjPhaseReal (Gia_Obj_t *pObj)
static int	Gia_ObjIsTerm (Gia_Obj_t *pObj)
static int	Gia_ObjIsAndOrConst0 (Gia_Obj_t *pObj)
static int	Gia_ObjIsCi (Gia_Obj_t *pObj)
static int	Gia_ObjIsCo (Gia_Obj_t *pObj)
static int	Gia_ObjIsAnd (Gia_Obj_t *pObj)
static int	Gia_ObjIsXor (Gia_Obj_t *pObj)
static int	Gia_ObjIsMuxId (Gia_Man_t *p, int iObj)
static int	Gia_ObjIsMux (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsAndReal (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsBuf (Gia_Obj_t *pObj)
static int	Gia_ObjIsAndNotBuf (Gia_Obj_t *pObj)
static int	Gia_ObjIsCand (Gia_Obj_t *pObj)
static int	Gia_ObjIsConst0 (Gia_Obj_t *pObj)
static int	Gia_ManObjIsConst0 (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_Obj2Lit (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_Lit2Obj (Gia_Man_t *p, int iLit)
static int	Gia_ManCiLit (Gia_Man_t *p, int CiId)
static int	Gia_ManIdToCioId (Gia_Man_t *p, int Id)
static int	Gia_ManCiIdToId (Gia_Man_t *p, int CiId)
static int	Gia_ManCoIdToId (Gia_Man_t *p, int CoId)
static int	Gia_ObjIsPi (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsPo (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsRo (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsRi (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjRoToRi (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjRiToRo (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjDiff0 (Gia_Obj_t *pObj)
static int	Gia_ObjDiff1 (Gia_Obj_t *pObj)
static int	Gia_ObjFaninC0 (Gia_Obj_t *pObj)
static int	Gia_ObjFaninC1 (Gia_Obj_t *pObj)
static int	Gia_ObjFaninC2 (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjFanin0 (Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjFanin1 (Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjFanin2 (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjChild0 (Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjChild1 (Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjChild2 (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFaninId0 (Gia_Obj_t *pObj, int ObjId)
static int	Gia_ObjFaninId1 (Gia_Obj_t *pObj, int ObjId)
static int	Gia_ObjFaninId2 (Gia_Man_t *p, int ObjId)
static int	Gia_ObjFaninId0p (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFaninId1p (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFaninId2p (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFaninLit0 (Gia_Obj_t *pObj, int ObjId)
static int	Gia_ObjFaninLit1 (Gia_Obj_t *pObj, int ObjId)
static int	Gia_ObjFaninLit2 (Gia_Man_t *p, int ObjId)
static int	Gia_ObjFaninLit0p (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFaninLit1p (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFaninLit2p (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjFlipFaninC0 (Gia_Obj_t *pObj)
static int	Gia_ObjWhatFanin (Gia_Obj_t *pObj, Gia_Obj_t *pFanin)
static int	Gia_ManPoIsConst0 (Gia_Man_t *p, int iPoIndex)
static int	Gia_ManPoIsConst1 (Gia_Man_t *p, int iPoIndex)
static Gia_Obj_t *	Gia_ObjCopy (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjLitCopy (Gia_Man_t *p, int iLit)
static int	Gia_ObjFanin0Copy (Gia_Obj_t *pObj)
static int	Gia_ObjFanin1Copy (Gia_Obj_t *pObj)
static int	Gia_ObjFanin2Copy (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjCopyF (Gia_Man_t *p, int f, Gia_Obj_t *pObj)
static void	Gia_ObjSetCopyF (Gia_Man_t *p, int f, Gia_Obj_t *pObj, int iLit)
static int	Gia_ObjCopyArray (Gia_Man_t *p, int iObj)
static void	Gia_ObjSetCopyArray (Gia_Man_t *p, int iObj, int iLit)
static void	Gia_ManCleanCopyArray (Gia_Man_t *p)
static int	Gia_ObjFanin0CopyF (Gia_Man_t *p, int f, Gia_Obj_t *pObj)
static int	Gia_ObjFanin1CopyF (Gia_Man_t *p, int f, Gia_Obj_t *pObj)
static int	Gia_ObjFanin0CopyArray (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFanin1CopyArray (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjFromLit (Gia_Man_t *p, int iLit)
static int	Gia_ObjToLit (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjPhaseRealLit (Gia_Man_t *p, int iLit)
static int	Gia_ObjLevelId (Gia_Man_t *p, int Id)
static int	Gia_ObjLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetLevelId (Gia_Man_t *p, int Id, int l)
static void	Gia_ObjSetLevel (Gia_Man_t *p, Gia_Obj_t *pObj, int l)
static void	Gia_ObjSetCoLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetBufLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetAndLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetXorLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetMuxLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetGateLevel (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjHasNumId (Gia_Man_t *p, int Id)
static int	Gia_ObjNumId (Gia_Man_t *p, int Id)
static int	Gia_ObjNum (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetNumId (Gia_Man_t *p, int Id, int n)
static void	Gia_ObjSetNum (Gia_Man_t *p, Gia_Obj_t *pObj, int n)
static void	Gia_ObjResetNumId (Gia_Man_t *p, int Id)
static int	Gia_ObjRefNumId (Gia_Man_t *p, int Id)
static int	Gia_ObjRefIncId (Gia_Man_t *p, int Id)
static int	Gia_ObjRefDecId (Gia_Man_t *p, int Id)
static int	Gia_ObjRefNum (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjRefInc (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjRefDec (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjRefFanin0Inc (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjRefFanin1Inc (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjRefFanin2Inc (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjRefFanin0Dec (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjRefFanin1Dec (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjRefFanin2Dec (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetTravIdCurrent (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetTravIdPrevious (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsTravIdCurrent (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjIsTravIdPrevious (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetTravIdCurrentId (Gia_Man_t *p, int Id)
static int	Gia_ObjIsTravIdCurrentId (Gia_Man_t *p, int Id)
static void	Gia_ManTimeClean (Gia_Man_t *p)
static void	Gia_ManTimeStart (Gia_Man_t *p)
static void	Gia_ManTimeStop (Gia_Man_t *p)
static float	Gia_ObjTimeArrival (Gia_Man_t *p, int Id)
static float	Gia_ObjTimeRequired (Gia_Man_t *p, int Id)
static float	Gia_ObjTimeSlack (Gia_Man_t *p, int Id)
static float	Gia_ObjTimeArrivalObj (Gia_Man_t *p, Gia_Obj_t *pObj)
static float	Gia_ObjTimeRequiredObj (Gia_Man_t *p, Gia_Obj_t *pObj)
static float	Gia_ObjTimeSlackObj (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjSetTimeArrival (Gia_Man_t *p, int Id, float t)
static void	Gia_ObjSetTimeRequired (Gia_Man_t *p, int Id, float t)
static void	Gia_ObjSetTimeSlack (Gia_Man_t *p, int Id, float t)
static void	Gia_ObjSetTimeArrivalObj (Gia_Man_t *p, Gia_Obj_t *pObj, float t)
static void	Gia_ObjSetTimeRequiredObj (Gia_Man_t *p, Gia_Obj_t *pObj, float t)
static void	Gia_ObjSetTimeSlackObj (Gia_Man_t *p, Gia_Obj_t *pObj, float t)
static int	Gia_ObjSimWords (Gia_Man_t *p)
static word *	Gia_ObjSimPi (Gia_Man_t *p, int PiId)
static word *	Gia_ObjSim (Gia_Man_t *p, int Id)
static word *	Gia_ObjSimObj (Gia_Man_t *p, Gia_Obj_t *pObj)
void	Gia_ObjAddFanout (Gia_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pFanout)
static Gia_Obj_t *	Gia_ManAppendObj (Gia_Man_t *p)
static int	Gia_ManAppendCi (Gia_Man_t *p)
static int	Gia_ManAppendAnd (Gia_Man_t *p, int iLit0, int iLit1)
static int	Gia_ManAppendAnd2 (Gia_Man_t *p, int iLit0, int iLit1)
static int	Gia_ManAppendXorReal (Gia_Man_t *p, int iLit0, int iLit1)
static int	Gia_ManAppendMuxReal (Gia_Man_t *p, int iLitC, int iLit1, int iLit0)
static int	Gia_ManAppendBuf (Gia_Man_t *p, int iLit)
static int	Gia_ManAppendCo (Gia_Man_t *p, int iLit0)
static int	Gia_ManAppendOr (Gia_Man_t *p, int iLit0, int iLit1)
static int	Gia_ManAppendMux (Gia_Man_t *p, int iCtrl, int iData1, int iData0)
static int	Gia_ManAppendMaj (Gia_Man_t *p, int iData0, int iData1, int iData2)
static int	Gia_ManAppendXor (Gia_Man_t *p, int iLit0, int iLit1)
static void	Gia_ManPatchCoDriver (Gia_Man_t *p, int iCoIndex, int iLit0)
static int	Gia_XsimNotCond (int Value, int fCompl)
static int	Gia_XsimAndCond (int Value0, int fCompl0, int Value1, int fCompl1)
static void	Gia_ObjTerSimSetC (Gia_Obj_t *pObj)
static void	Gia_ObjTerSimSet0 (Gia_Obj_t *pObj)
static void	Gia_ObjTerSimSet1 (Gia_Obj_t *pObj)
static void	Gia_ObjTerSimSetX (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGetC (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGet0 (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGet1 (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGetX (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGet0Fanin0 (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGet1Fanin0 (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGet0Fanin1 (Gia_Obj_t *pObj)
static int	Gia_ObjTerSimGet1Fanin1 (Gia_Obj_t *pObj)
static void	Gia_ObjTerSimAnd (Gia_Obj_t *pObj)
static void	Gia_ObjTerSimCo (Gia_Obj_t *pObj)
static void	Gia_ObjTerSimRo (Gia_Man_t *p, Gia_Obj_t *pObj)
static void	Gia_ObjTerSimPrint (Gia_Obj_t *pObj)
static int	Gia_AigerReadInt (unsigned char *pPos)
static void	Gia_AigerWriteInt (unsigned char *pPos, int Value)
static unsigned	Gia_AigerReadUnsigned (unsigned char **ppPos)
static void	Gia_AigerWriteUnsigned (Vec_Str_t *vStr, unsigned x)
static void	Gia_AigerWriteUnsignedFile (FILE *pFile, unsigned x)
static int	Gia_AigerWriteUnsignedBuffer (unsigned char *pBuffer, int Pos, unsigned x)
static Gia_Obj_t *	Gia_ObjReprObj (Gia_Man_t *p, int Id)
static int	Gia_ObjRepr (Gia_Man_t *p, int Id)
static void	Gia_ObjSetRepr (Gia_Man_t *p, int Id, int Num)
static void	Gia_ObjSetReprRev (Gia_Man_t *p, int Id, int Num)
static void	Gia_ObjUnsetRepr (Gia_Man_t *p, int Id)
static int	Gia_ObjHasRepr (Gia_Man_t *p, int Id)
static int	Gia_ObjReprSelf (Gia_Man_t *p, int Id)
static int	Gia_ObjSibl (Gia_Man_t *p, int Id)
static Gia_Obj_t *	Gia_ObjSiblObj (Gia_Man_t *p, int Id)
static int	Gia_ObjProved (Gia_Man_t *p, int Id)
static void	Gia_ObjSetProved (Gia_Man_t *p, int Id)
static void	Gia_ObjUnsetProved (Gia_Man_t *p, int Id)
static int	Gia_ObjFailed (Gia_Man_t *p, int Id)
static void	Gia_ObjSetFailed (Gia_Man_t *p, int Id)
static int	Gia_ObjColor (Gia_Man_t *p, int Id, int c)
static int	Gia_ObjColors (Gia_Man_t *p, int Id)
static void	Gia_ObjSetColor (Gia_Man_t *p, int Id, int c)
static void	Gia_ObjSetColors (Gia_Man_t *p, int Id)
static int	Gia_ObjVisitColor (Gia_Man_t *p, int Id, int c)
static int	Gia_ObjDiffColors (Gia_Man_t *p, int i, int j)
static int	Gia_ObjDiffColors2 (Gia_Man_t *p, int i, int j)
static Gia_Obj_t *	Gia_ObjNextObj (Gia_Man_t *p, int Id)
static int	Gia_ObjNext (Gia_Man_t *p, int Id)
static void	Gia_ObjSetNext (Gia_Man_t *p, int Id, int Num)
static int	Gia_ObjIsConst (Gia_Man_t *p, int Id)
static int	Gia_ObjIsHead (Gia_Man_t *p, int Id)
static int	Gia_ObjIsNone (Gia_Man_t *p, int Id)
static int	Gia_ObjIsTail (Gia_Man_t *p, int Id)
static int	Gia_ObjIsClass (Gia_Man_t *p, int Id)
static int	Gia_ObjHasSameRepr (Gia_Man_t *p, int i, int k)
static int	Gia_ObjIsFailedPair (Gia_Man_t *p, int i, int k)
static int	Gia_ClassIsPair (Gia_Man_t *p, int i)
static void	Gia_ClassUndoPair (Gia_Man_t *p, int i)
static int	Gia_ObjFoffsetId (Gia_Man_t *p, int Id)
static int	Gia_ObjFoffset (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFanoutNumId (Gia_Man_t *p, int Id)
static int	Gia_ObjFanoutNum (Gia_Man_t *p, Gia_Obj_t *pObj)
static int	Gia_ObjFanoutId (Gia_Man_t *p, int Id, int i)
static Gia_Obj_t *	Gia_ObjFanout0 (Gia_Man_t *p, Gia_Obj_t *pObj)
static Gia_Obj_t *	Gia_ObjFanout (Gia_Man_t *p, Gia_Obj_t *pObj, int i)
static void	Gia_ObjSetFanout (Gia_Man_t *p, Gia_Obj_t *pObj, int i, Gia_Obj_t *pFan)
static int	Gia_ManHasMapping (Gia_Man_t *p)
static int	Gia_ObjIsLut (Gia_Man_t *p, int Id)
static int	Gia_ObjLutSize (Gia_Man_t *p, int Id)
static int *	Gia_ObjLutFanins (Gia_Man_t *p, int Id)
static int	Gia_ObjLutFanin (Gia_Man_t *p, int Id, int i)
static int	Gia_ObjLutMuxId (Gia_Man_t *p, int Id)
static int	Gia_ObjLutIsMux (Gia_Man_t *p, int Id)
static int	Gia_ManHasCellMapping (Gia_Man_t *p)
static int	Gia_ObjIsCell (Gia_Man_t *p, int iLit)
static int	Gia_ObjIsCellInv (Gia_Man_t *p, int iLit)
static int	Gia_ObjIsCellBuf (Gia_Man_t *p, int iLit)
static int	Gia_ObjCellSize (Gia_Man_t *p, int iLit)
static int *	Gia_ObjCellFanins (Gia_Man_t *p, int iLit)
static int	Gia_ObjCellFanin (Gia_Man_t *p, int iLit, int i)
static int	Gia_ObjCellId (Gia_Man_t *p, int iLit)
int	Gia_FileSize (char *pFileName)
	FUNCTION DECLARATIONS ///. More...
Gia_Man_t *	Gia_AigerReadFromMemory (char *pContents, int nFileSize, int fSkipStrash, int fCheck)
Gia_Man_t *	Gia_AigerRead (char *pFileName, int fSkipStrash, int fCheck)
void	Gia_AigerWrite (Gia_Man_t *p, char *pFileName, int fWriteSymbols, int fCompact)
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 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 ///. More...
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)
Vec_Int_t *	Cbs_ManSolveMiterNc (Gia_Man_t *pGia, int nConfs, Vec_Str_t **pvStatus, int fVerbose)
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)
void	Gia_ManCollectCis (Gia_Man_t *p, int *pNodes, int nNodes, Vec_Int_t *vSupp)
void	Gia_ManCollectAnds (Gia_Man_t *p, int *pNodes, int nNodes, Vec_Int_t *vNodes)
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_Int_t *	Gia_ManOrderReverse (Gia_Man_t *p)
void	Gia_ManDupRemapEquiv (Gia_Man_t *pNew, Gia_Man_t *p)
	DECLARATIONS ///. More...
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)
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_ManDupWithAttributes (Gia_Man_t *p)
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_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_ManDupExist (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_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_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_ManDupAndOr (Gia_Man_t *p, int nOuts, int fUseOr, int fCompl)
Gia_Man_t *	Gia_ManDupZeroUndc (Gia_Man_t *p, char *pInit, 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_ManTransformToDual (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_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)
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_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)
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_ObjRemoveFanout (Gia_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pFanout)
void	Gia_ManFanoutStart (Gia_Man_t *p)
	FUNCTION DEFINITIONS ///. More...
void	Gia_ManFanoutStop (Gia_Man_t *p)
void	Gia_ManStaticFanoutStart (Gia_Man_t *p)
void	Gia_ManStaticFanoutStop (Gia_Man_t *p)
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_ManHashLookup (Gia_Man_t *p, Gia_Obj_t *p0, Gia_Obj_t *p1)
int	Gia_ManHashAndMulti (Gia_Man_t *p, Vec_Int_t *vLits)
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)
void	Gia_ManLutParams (Gia_Man_t *p, int *pnCurLuts, int *pnCurEdges, int *pnCurLevels)
void	Gia_ManSetRefsMapped (Gia_Man_t *p)
void	Gia_ManSetIfParsDefault (void *pIfPars)
	FUNCTION DEFINITIONS ///. More...
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)
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)
	DECLARATIONS ///. More...
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)
Gia_MmFixed_t *	Gia_MmFixedStart (int nEntrySize, int nEntriesMax)
	FUNCTION DEFINITIONS ///. More...
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)
Gia_Man_t *	Gia_ManReadMiniAig (char *pFileName)
void	Gia_ManWriteMiniAig (Gia_Man_t *pGia, char *pFileName)
void	Gia_ManCountMuxXor (Gia_Man_t *p, int *pnMuxes, int *pnXors)
	DECLARATIONS ///. More...
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)
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)
Gia_Man_t *	Gia_ManMapShrink4 (Gia_Man_t *p, int fKeepLevel, int fVerbose)
	FUNCTION DEFINITIONS ///. More...
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)
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_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_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)
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_Flt_t *	Gia_ManPrintOutputProb (Gia_Man_t *p)
int	Gia_ManBoxNum (Gia_Man_t *p)
	DECLARATIONS ///. More...
int	Gia_ManRegBoxNum (Gia_Man_t *p)
int	Gia_ManNonRegBoxNum (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)
Gia_Man_t *	Gia_ManDupNormalize (Gia_Man_t *p)
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 fVerbose, char *pFileSpec)
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)
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 ///. More...
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)
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)
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)
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_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_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)
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)

Macro Definition Documentation

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

Definition at line 977 of file gia.h.

#define Gia_ClassForEachObj	(		p,
			i,
			iObj
	)		for ( assert(Gia_ObjIsHead(p, i)), iObj = i; iObj; iObj = Gia_ObjNext(p, iObj) )

Definition at line 931 of file gia.h.

#define Gia_ClassForEachObj1	(		p,
			i,
			iObj
	)		for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, i); iObj; iObj = Gia_ObjNext(p, iObj) )

Definition at line 933 of file gia.h.

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

Definition at line 970 of file gia.h.

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

Definition at line 972 of file gia.h.

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

Definition at line 1002 of file gia.h.

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

Definition at line 1004 of file gia.h.

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

Definition at line 1010 of file gia.h.

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

Definition at line 1012 of file gia.h.

#define Gia_ManForEachBuf	(		p,
			pObj,
			i
	)		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 998 of file gia.h.

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

Definition at line 1000 of file gia.h.

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

Definition at line 1008 of file gia.h.

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

Definition at line 975 of file gia.h.

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

Definition at line 1016 of file gia.h.

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

Definition at line 1018 of file gia.h.

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

Definition at line 1020 of file gia.h.

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

Definition at line 927 of file gia.h.

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

Definition at line 929 of file gia.h.

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

Definition at line 1022 of file gia.h.

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

Definition at line 1030 of file gia.h.

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

Definition at line 1032 of file gia.h.

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

Definition at line 1026 of file gia.h.

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

Definition at line 925 of file gia.h.

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

Definition at line 1028 of file gia.h.

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

Definition at line 1024 of file gia.h.

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

Definition at line 968 of file gia.h.

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

Definition at line 1014 of file gia.h.

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

Definition at line 1006 of file gia.h.

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

MACRO DEFINITIONS ///.

Definition at line 984 of file gia.h.

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

Definition at line 986 of file gia.h.

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

Definition at line 994 of file gia.h.

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

Definition at line 996 of file gia.h.

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

Definition at line 988 of file gia.h.

#define Gia_ManForEachObjVecLit	(		vVec,
			p,
			pObj,
			fCompl,
			i
	)		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 992 of file gia.h.

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

Definition at line 990 of file gia.h.

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

Definition at line 1034 of file gia.h.

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

Definition at line 1036 of file gia.h.

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

Definition at line 1040 of file gia.h.

#define Gia_ManForEachRiRo	(		p,
			pObjRi,
			pObjRo,
			i
	)		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 1042 of file gia.h.

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

Definition at line 1038 of file gia.h.

#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 44 of file gia.h.

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

Definition at line 946 of file gia.h.

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

Definition at line 948 of file gia.h.

#define GIA_ONE   2

Definition at line 748 of file gia.h.

#define GIA_UND   3

Definition at line 749 of file gia.h.

#define GIA_VOID   0x0FFFFFFF

Definition at line 45 of file gia.h.

#define GIA_ZER   1

Definition at line 747 of file gia.h.

Typedef Documentation

typedef struct Emb_Par_t_ Emb_Par_t

Definition at line 208 of file gia.h.

typedef struct Gia_Man_t_ Gia_Man_t

Definition at line 94 of file gia.h.

typedef struct Gia_ManSim_t_ Gia_ManSim_t

Definition at line 250 of file gia.h.

typedef struct Gia_MmFixed_t_ Gia_MmFixed_t

BASIC TYPES ///.

Definition at line 51 of file gia.h.

typedef struct Gia_MmFlex_t_ Gia_MmFlex_t

Definition at line 52 of file gia.h.

typedef struct Gia_MmStep_t_ Gia_MmStep_t

Definition at line 53 of file gia.h.

typedef struct Gia_Obj_t_ Gia_Obj_t

Definition at line 74 of file gia.h.

typedef struct Gia_ParFra_t_ Gia_ParFra_t

Definition at line 224 of file gia.h.

typedef struct Gia_ParSim_t_ Gia_ParSim_t

Definition at line 237 of file gia.h.

typedef struct Gia_Plc_t_ Gia_Plc_t

Definition at line 65 of file gia.h.

typedef struct Gia_Rpr_t_ Gia_Rpr_t

Definition at line 55 of file gia.h.

typedef struct Gps_Par_t_ Gps_Par_t

Definition at line 194 of file gia.h.

typedef struct Jf_Par_t_ Jf_Par_t

Definition at line 264 of file gia.h.

typedef struct Tas_Man_t_ Tas_Man_t

Definition at line 1448 of file gia.h.

Function Documentation

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

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

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

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

Synopsis [Procedure to test the new SAT solver.]

Description []

SideEffects []

SeeAlso []

Definition at line 998 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();
    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      = 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 )
        {
            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;
}

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

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

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 821 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, 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;
}

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

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

    // 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 ( !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 ( 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 ( !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 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, Vec_StrSize(vStr) );
                pCur += Vec_StrSize(vStr);
                pNew->pAigExtra = Gia_AigerReadFromMemory( Vec_StrArray(vStr), Vec_StrSize(vStr), 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, 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, 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, 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, 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, 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') )
                {
                    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, 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++;
                nRegs = Gia_AigerReadInt(pCur)/4;                       pCur += 4;
                pNew->vRegClasses = Vec_IntAlloc( nRegs );
                for ( i = 0; i < nRegs; i++ )
                    Vec_IntPush( pNew->vRegClasses, Gia_AigerReadInt(pCur) ), pCur += 4;
                if ( fVerbose ) printf( "Finished reading extension \"r\".\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, 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, 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, 4*Vec_IntSize(pNew->vObjClasses) );
                pCur += 4*Vec_IntSize(pNew->vObjClasses);
                if ( fVerbose ) printf( "Finished reading extension \"v\".\n" );
            }
            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 ( !fSkipStrash && Gia_ManHasDangling(pNew) )
    {
        Tim_Man_t * pManTime;
        Vec_Int_t * vFlopMap, * vGateMap, * vObjMap;
        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;
        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->vFlopClasses = vFlopMap;
        pNew->vGateClasses = vGateMap;
        pNew->vObjClasses  = vObjMap;
        pNew->pManTime     = pManTime;
    }

    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;
        pNew = Gia_ManDupZeroUndc( pTemp = pNew, pInit, 1 );
        pNew->nConstrs = pTemp->nConstrs; pTemp->nConstrs = 0;
        Gia_ManStop( pTemp );
        ABC_FREE( pInit );
    }
    Vec_IntFreeP( &vInits );
    if ( !fSkipStrash && pNew->vMapping )
    {
        Abc_Print( 0, "Structural hashing enabled while reading AIGER invalidated the mapping.  Consider using \"&r -s\".\n" );
        Vec_IntFreeP( &pNew->vMapping );
    }
    return pNew;
}

static int Gia_AigerReadInt ( unsigned char *  pPos )

inlinestatic

Definition at line 827 of file gia.h.

{
    int i, Value = 0;
    for ( i = 0; i < 4; i++ )
        Value = (Value << 8) | *pPos++;
    return Value;
}

static unsigned Gia_AigerReadUnsigned ( unsigned char **  ppPos )

inlinestatic

Definition at line 840 of file gia.h.

{
    unsigned x = 0, i = 0;
    unsigned char ch;
    while ((ch = *(*ppPos)++) & 0x80)
        x |= (ch & 0x7f) << (7 * i++);
    return x | (ch << (7 * i));
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1024 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 );
        Gia_ManTransferMapping( p, pInit );
        Gia_ManTransferPacking( p, pInit );
        Gia_ManTransferTiming( p, pInit );
        p->vNamesIn   = pInit->vNamesIn;   pInit->vNamesIn   = NULL;
        p->vNamesOut  = pInit->vNamesOut;  pInit->vNamesOut  = NULL;
        p->nConstrs   = pInit->nConstrs;   pInit->nConstrs   = 0;
    }
    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( 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) );
    }

    // write the comment
//    fprintf( pFile, "c\n" );
    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 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 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) );
        for ( i = 0; i < Vec_IntSize(p->vRegClasses); i++ )
            Gia_FileWriteBufferSize( pFile, Vec_IntEntry(p->vRegClasses, 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
    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 )
    {
        pInit->pManTime  = p->pManTime;  p->pManTime = NULL;
        pInit->vNamesIn  = p->vNamesIn;  p->vNamesIn = NULL;
        pInit->vNamesOut = p->vNamesOut; p->vNamesOut = NULL;
        Gia_ManStop( p );
    }
}

static void Gia_AigerWriteInt ( unsigned char *  pPos, int  Value  )

inlinestatic

Definition at line 834 of file gia.h.

{
    int i;
    for ( i = 3; i >= 0; i-- )
        *pPos++ = (Value >> (8*i)) & 255;
}

Vec_Str_t* Gia_AigerWriteIntoMemoryStr

(

Gia_Man_t *

p

)

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 866 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;
}

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

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 940 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;
}

void Gia_AigerWriteSimple	(	Gia_Man_t *	pInit,
		char *	pFileName
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1361 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 );
}

static void Gia_AigerWriteUnsigned ( Vec_Str_t *  vStr, unsigned  x  )

inlinestatic

Definition at line 848 of file gia.h.

{
    unsigned char ch;
    while (x & ~0x7f)
    {
        ch = (x & 0x7f) | 0x80;
        Vec_StrPush( vStr, ch );
        x >>= 7;
    }
    ch = x;
    Vec_StrPush( vStr, ch );
}

static int Gia_AigerWriteUnsignedBuffer ( unsigned char *  pBuffer, int  Pos, unsigned  x  )

inlinestatic

Definition at line 872 of file gia.h.

{
    unsigned char ch;
    while (x & ~0x7f)
    {
        ch = (x & 0x7f) | 0x80;
        pBuffer[Pos++] = ch;
        x >>= 7;
    }
    ch = x;
    pBuffer[Pos++] = ch;
    return Pos;
}

static void Gia_AigerWriteUnsignedFile ( FILE *  pFile, unsigned  x  )

inlinestatic

Definition at line 860 of file gia.h.

{
    unsigned char ch;
    while (x & ~0x7f)
    {
        ch = (x & 0x7f) | 0x80;
        fputc( ch, pFile );
        x >>= 7;
    }
    ch = x;
    fputc( ch, pFile );
}

static int Gia_ClassIsPair ( Gia_Man_t *  p, int  i  )

inlinestatic

Definition at line 922 of file gia.h.

{ assert( Gia_ObjIsHead(p, i) ); assert( Gia_ObjNext(p, i) ); return Gia_ObjNext(p, Gia_ObjNext(p, i)) == 0;     }

static void Gia_ClassUndoPair ( Gia_Man_t *  p, int  i  )

inlinestatic

Definition at line 923 of file gia.h.

{ assert( Gia_ClassIsPair(p,i) ); Gia_ObjSetRepr(p, Gia_ObjNext(p, i), GIA_VOID); Gia_ObjSetNext(p, i, 0);       }

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1343 of file giaAiger.c.

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

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

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

Synopsis [Returns the composite name of the file.]

Description []

SideEffects []

SeeAlso []

Definition at line 125 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;
}

int Gia_FileSize

(

char *

pFileName

)

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

static int Gia_IsComplement ( Gia_Obj_t *  p )

inlinestatic

Definition at line 380 of file gia.h.

{ return (int)((ABC_PTRUINT_T)(p) & 01);                                    }

static Gia_Obj_t* Gia_Lit2Obj ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 434 of file gia.h.

{ return Gia_NotCond(Gia_ManObj(p, Abc_Lit2Var(iLit)), Abc_LitIsCompl(iLit));  }

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

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 )
        return p;
    // 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;
}

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

Definition at line 152 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 )
        return Gia_ManDup(p);
    // 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;
}

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

Definition at line 184 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 )
        return Gia_ManDup(p);
//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;
}

static int Gia_ManAndNotBufNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 393 of file gia.h.

{ return Gia_ManAndNum(p) - Gia_ManBufNum(p);                               }

static int Gia_ManAndNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 389 of file gia.h.

{ return p->nObjs - Vec_IntSize(p->vCis) - Vec_IntSize(p->vCos) - 1;        }

static int Gia_ManAppendAnd ( Gia_Man_t *  p, int  iLit0, int  iLit1  )

inlinestatic

Definition at line 592 of file gia.h.

{ 
    Gia_Obj_t * pObj = Gia_ManAppendObj( p );
    assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
    assert( iLit1 >= 0 && Abc_Lit2Var(iLit1) < Gia_ManObjNum(p) );
    assert( Abc_Lit2Var(iLit0) != Abc_Lit2Var(iLit1) );
    if ( iLit0 < iLit1 )
    {
        pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
        pObj->fCompl0 = Abc_LitIsCompl(iLit0);
        pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1);
        pObj->fCompl1 = Abc_LitIsCompl(iLit1);
    }
    else
    {
        pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
        pObj->fCompl1 = Abc_LitIsCompl(iLit0);
        pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1);
        pObj->fCompl0 = Abc_LitIsCompl(iLit1);
    }
    if ( p->pFanData )
    {
        Gia_ObjAddFanout( p, Gia_ObjFanin0(pObj), pObj );
        Gia_ObjAddFanout( p, Gia_ObjFanin1(pObj), pObj );
    }
    if ( p->fSweeper )
    {
        Gia_Obj_t * pFan0 = Gia_ObjFanin0(pObj);
        Gia_Obj_t * pFan1 = Gia_ObjFanin1(pObj);
        if ( pFan0->fMark0 ) pFan0->fMark1 = 1; else pFan0->fMark0 = 1;
        if ( pFan1->fMark0 ) pFan1->fMark1 = 1; else pFan1->fMark0 = 1;
        pObj->fPhase = (Gia_ObjPhase(pFan0) ^ Gia_ObjFaninC0(pObj)) & (Gia_ObjPhase(pFan1) ^ Gia_ObjFaninC1(pObj));
    }
    return Gia_ObjId( p, pObj ) << 1;
}

static int Gia_ManAppendAnd2 ( Gia_Man_t *  p, int  iLit0, int  iLit1  )

inlinestatic

Definition at line 627 of file gia.h.

{ 
    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;
    return Gia_ManAppendAnd( p, iLit0, iLit1 );
}

static int Gia_ManAppendBuf ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 694 of file gia.h.

{ 
    Gia_Obj_t * pObj = Gia_ManAppendObj( p );
    assert( iLit >= 0 && Abc_Lit2Var(iLit) < Gia_ManObjNum(p) );
    pObj->iDiff0  = pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit);
    pObj->fCompl0 = pObj->fCompl1 = Abc_LitIsCompl(iLit);
    p->nBufs++;
    return Gia_ObjId( p, pObj ) << 1;
}

static int Gia_ManAppendCi ( Gia_Man_t *  p )

inlinestatic

Definition at line 583 of file gia.h.

{ 
    Gia_Obj_t * pObj = Gia_ManAppendObj( p );
    pObj->fTerm = 1;
    pObj->iDiff0 = GIA_NONE;
    pObj->iDiff1 = Vec_IntSize( p->vCis );
    Vec_IntPush( p->vCis, Gia_ObjId(p, pObj) );
    return Gia_ObjId( p, pObj ) << 1;
}

static int Gia_ManAppendCo ( Gia_Man_t *  p, int  iLit0  )

inlinestatic

Definition at line 703 of file gia.h.

{ 
    Gia_Obj_t * pObj;
    assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
    assert( !Gia_ObjIsCo(Gia_ManObj(p, Abc_Lit2Var(iLit0))) );
    pObj = Gia_ManAppendObj( p );    
    pObj->fTerm = 1;
    pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
    pObj->fCompl0 = Abc_LitIsCompl(iLit0);
    pObj->iDiff1  = Vec_IntSize( p->vCos );
    Vec_IntPush( p->vCos, Gia_ObjId(p, pObj) );
    if ( p->pFanData )
        Gia_ObjAddFanout( p, Gia_ObjFanin0(pObj), pObj );
    return Gia_ObjId( p, pObj ) << 1;
}

static int Gia_ManAppendMaj ( Gia_Man_t *  p, int  iData0, int  iData1, int  iData2  )

inlinestatic

Definition at line 728 of file gia.h.

{ 
    int iTemp0 = Gia_ManAppendOr( p, iData1, iData2 );
    int iTemp1 = Gia_ManAppendAnd( p, iData0, iTemp0 );
    int iTemp2 = Gia_ManAppendAnd( p, iData1, iData2 );
    return Gia_ManAppendOr( p, iTemp1, iTemp2 );
}

static int Gia_ManAppendMux ( Gia_Man_t *  p, int  iCtrl, int  iData1, int  iData0  )

inlinestatic

Definition at line 722 of file gia.h.

{ 
    int iTemp0 = Gia_ManAppendAnd( p, Abc_LitNot(iCtrl), iData0 );
    int iTemp1 = Gia_ManAppendAnd( p, iCtrl, iData1 );
    return Abc_LitNotCond( Gia_ManAppendAnd( p, Abc_LitNot(iTemp0), Abc_LitNot(iTemp1) ), 1 );
}

static int Gia_ManAppendMuxReal ( Gia_Man_t *  p, int  iLitC, int  iLit1, int  iLit0  )

inlinestatic

Definition at line 664 of file gia.h.

{ 
    Gia_Obj_t * pObj = Gia_ManAppendObj( p );
    assert( p->pMuxes != NULL );
    assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
    assert( iLit1 >= 0 && Abc_Lit2Var(iLit1) < Gia_ManObjNum(p) );
    assert( iLitC >= 0 && Abc_Lit2Var(iLitC) < Gia_ManObjNum(p) );
    assert( Abc_Lit2Var(iLit0) != Abc_Lit2Var(iLit1) );
    assert( Abc_Lit2Var(iLitC) != Abc_Lit2Var(iLit0) );
    assert( Abc_Lit2Var(iLitC) != Abc_Lit2Var(iLit1) );
    assert( !p->pHTable || !Abc_LitIsCompl(iLit1) );
    if ( Abc_Lit2Var(iLit0) < Abc_Lit2Var(iLit1) )
    {
        pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
        pObj->fCompl0 = Abc_LitIsCompl(iLit0);
        pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1);
        pObj->fCompl1 = Abc_LitIsCompl(iLit1);
        p->pMuxes[Gia_ObjId(p, pObj)] = iLitC;
    }
    else
    {
        pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
        pObj->fCompl1 = Abc_LitIsCompl(iLit0);
        pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1);
        pObj->fCompl0 = Abc_LitIsCompl(iLit1);
        p->pMuxes[Gia_ObjId(p, pObj)] = Abc_LitNot(iLitC);
    }
    p->nMuxes++;
    return Gia_ObjId( p, pObj ) << 1;
}

static Gia_Obj_t* Gia_ManAppendObj ( Gia_Man_t *  p )

inlinestatic

Definition at line 561 of file gia.h.

{ 
    if ( p->nObjs == p->nObjsAlloc )
    {
        int nObjNew = Abc_MinInt( 2 * p->nObjsAlloc, (1 << 29) );
        if ( p->nObjs == (1 << 29) )
            printf( "Hard limit on the number of nodes (2^29) is reached. Quitting...\n" ), exit(1);
        assert( p->nObjs < nObjNew );
        if ( p->fVerbose )
            printf("Extending GIA object storage: %d -> %d.\n", p->nObjsAlloc, nObjNew );
        assert( p->nObjsAlloc > 0 );
        p->pObjs = ABC_REALLOC( Gia_Obj_t, p->pObjs, nObjNew );
        memset( p->pObjs + p->nObjsAlloc, 0, sizeof(Gia_Obj_t) * (nObjNew - p->nObjsAlloc) );
        if ( p->pMuxes )
        {
            p->pMuxes = ABC_REALLOC( unsigned, p->pMuxes, nObjNew );
            memset( p->pMuxes + p->nObjsAlloc, 0, sizeof(unsigned) * (nObjNew - p->nObjsAlloc) );
        }
        p->nObjsAlloc = nObjNew;
    }
    return Gia_ManObj( p, p->nObjs++ );
}

static int Gia_ManAppendOr ( Gia_Man_t *  p, int  iLit0, int  iLit1  )

inlinestatic

Definition at line 718 of file gia.h.

{
    return Abc_LitNot(Gia_ManAppendAnd( p, Abc_LitNot(iLit0), Abc_LitNot(iLit1) ));
}

static int Gia_ManAppendXor ( Gia_Man_t *  p, int  iLit0, int  iLit1  )

inlinestatic

Definition at line 735 of file gia.h.

{ 
    return Gia_ManAppendMux( p, iLit0, Abc_LitNot(iLit1), iLit1 );
}

static int Gia_ManAppendXorReal ( Gia_Man_t *  p, int  iLit0, int  iLit1  )

inlinestatic

Definition at line 639 of file gia.h.

{ 
    Gia_Obj_t * pObj = Gia_ManAppendObj( p );
    assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
    assert( iLit1 >= 0 && Abc_Lit2Var(iLit1) < Gia_ManObjNum(p) );
    assert( Abc_Lit2Var(iLit0) != Abc_Lit2Var(iLit1) );
    assert( !Abc_LitIsCompl(iLit0) );
    assert( !Abc_LitIsCompl(iLit1) );
    if ( Abc_Lit2Var(iLit0) > Abc_Lit2Var(iLit1) )
    {
        pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
        pObj->fCompl0 = Abc_LitIsCompl(iLit0);
        pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1);
        pObj->fCompl1 = Abc_LitIsCompl(iLit1);
    }
    else
    {
        pObj->iDiff1  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
        pObj->fCompl1 = Abc_LitIsCompl(iLit0);
        pObj->iDiff0  = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1);
        pObj->fCompl0 = Abc_LitIsCompl(iLit1);
    }
    p->nXors++;
    return Gia_ObjId( p, pObj ) << 1;
}

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

Definition at line 968 of file giaBalAig.c.

{
    Gia_Man_t * pNew0, * pNew, * pNew1, * pNew2;
    Vec_Int_t * vCiLevels;
    // 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) : p;
    if ( fVerbose )     Gia_ManPrintStats( pNew0, NULL );
    // derive internal manager
    pNew = fSimpleAnd ? Gia_ManDup( pNew0 ) : Gia_ManDupMuxes( pNew0, 2 );
    if ( fVerbose )     Gia_ManPrintStats( pNew, NULL );
    if ( pNew0 != p ) Gia_ManStop( pNew0 );
    // perform the operation
    pNew1 = Dam_ManAreaBalanceInt( pNew, vCiLevels, nNewNodesMax, fVerbose, fVeryVerbose );
    if ( fVerbose )     Gia_ManPrintStats( pNew1, NULL );
    Gia_ManStop( pNew );
    Vec_IntFreeP( &vCiLevels );
    // derive the final result
    pNew2 = Gia_ManDupNoMuxes( pNew1 );
    if ( fVerbose )     Gia_ManPrintStats( pNew2, NULL );
    Gia_ManStop( pNew1 );
    // normalize if needed
    if ( !Gia_ManIsNormalized(pNew2) )
    {
        pNew2 = Gia_ManDupNormalize( pNew1 = pNew2 );
        Gia_ManStop( pNew1 );
    }
    Gia_ManTransferTiming( pNew2, p );
    return pNew2;
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 365 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 );
    if ( fVerbose )      Gia_ManPrintStats( pNew, NULL );
    pNew1 = Gia_ManBalanceInt( pNew );
    if ( fVerbose )      Gia_ManPrintStats( pNew1, NULL );
    Gia_ManStop( pNew );
    pNew2 = Gia_ManDupNoMuxes( pNew1 );
    if ( fVerbose )      Gia_ManPrintStats( pNew2, NULL );
    Gia_ManStop( pNew1 );
    return pNew2;
}

int Gia_ManBoxCiNum

(

Gia_Man_t *

p

)

Definition at line 61 of file giaTim.c.

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

int Gia_ManBoxCoNum

(

Gia_Man_t *

p

)

Definition at line 65 of file giaTim.c.

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

int Gia_ManBoxNum

(

Gia_Man_t *

p

)

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 49 of file giaTim.c.

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

static int Gia_ManBufNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 392 of file gia.h.

{ return p->nBufs;                                                          }

static int Gia_ManCandNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 394 of file gia.h.

{ return Gia_ManCiNum(p) + Gia_ManAndNum(p);                                }

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 349 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;
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 302 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;
}

int Gia_ManCheckCoPhase

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 450 of file giaUtil.c.

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

void Gia_ManCheckIntegrityWithBoxes

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 406 of file giaSweep.c.

{
    Gia_Obj_t * pObj;
    Vec_Int_t * vCarryOuts;
    int i, nCountReg = 0, nCountCarry = 0;
    if ( p->pManTime == NULL )
        return;
    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 );
}

void Gia_ManCheckMark0

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 234 of file giaUtil.c.

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

void Gia_ManCheckMark1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 291 of file giaUtil.c.

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

int Gia_ManCheckTopoOrder

(

Gia_Man_t *

p

)

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 73 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;
}

Gia_Man_t* Gia_ManChoiceMiter

(

Vec_Ptr_t *

vGias

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 2574 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;
}

static int Gia_ManChoiceNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 398 of file gia.h.

{ int c = 0; if (p->pSibls) { int i; for (i = 0; i < p->nObjs; i++) c += (int)(p->pSibls[i] > 0); } return c; } 

static Gia_Obj_t* Gia_ManCi ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 403 of file gia.h.

{ return Gia_ManObj( p, Vec_IntEntry(p->vCis,v) );                          }

static int Gia_ManCiIdToId ( Gia_Man_t *  p, int  CiId  )

inlinestatic

Definition at line 438 of file gia.h.

{ return Gia_ObjId( p, Gia_ManCi(p, CiId) );                  }

static int Gia_ManCiLit ( Gia_Man_t *  p, int  CiId  )

inlinestatic

Definition at line 435 of file gia.h.

{ return Gia_Obj2Lit( p, Gia_ManCi(p, CiId) );                }

static int Gia_ManCiNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 383 of file gia.h.

{ return Vec_IntSize(p->vCis);                                              }

static void Gia_ManCleanCopyArray ( Gia_Man_t *  p )

inlinestatic

Definition at line 489 of file gia.h.

{ Vec_IntFill( &p->vCopies, Gia_ManObjNum(p), -1 );                                }

void Gia_ManCleanLevels	(	Gia_Man_t *	p,
		int	Size
	)

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

Synopsis [Prepares copies for the model.]

Description []

SideEffects []

SeeAlso []

Definition at line 470 of file giaUtil.c.

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

void Gia_ManCleanMark0

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 215 of file giaUtil.c.

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

void Gia_ManCleanMark01

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 177 of file giaUtil.c.

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

void Gia_ManCleanMark1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 272 of file giaUtil.c.

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

void Gia_ManCleanPhase

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 431 of file giaUtil.c.

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

void Gia_ManCleanTruth

(

Gia_Man_t *

p

)

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

Synopsis [Prepares copies for the model.]

Description []

SideEffects []

SeeAlso []

Definition at line 487 of file giaUtil.c.

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

Gia_Man_t* Gia_ManCleanup

(

Gia_Man_t *

p

)

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

Synopsis [Performs combinational cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 84 of file giaScl.c.

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

Gia_Man_t* Gia_ManCleanupOutputs	(	Gia_Man_t *	p,
		int	nOutputs
	)

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

void Gia_ManCleanValue

(

Gia_Man_t *

p

)

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

Synopsis [Cleans the value.]

Description []

SideEffects []

SeeAlso []

Definition at line 310 of file giaUtil.c.

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

int Gia_ManClockDomainNum

(

Gia_Man_t *

p

)

Definition at line 69 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;    
}

static Gia_Obj_t* Gia_ManCo ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 404 of file gia.h.

{ return Gia_ManObj( p, Vec_IntEntry(p->vCos,v) );                          }

static int Gia_ManCoIdToId ( Gia_Man_t *  p, int  CoId  )

inlinestatic

Definition at line 439 of file gia.h.

{ return Gia_ObjId( p, Gia_ManCo(p, CoId) );                  }

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

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 123 of file giaDfs.c.

{
    Gia_Obj_t * pObj;
    int i; 
    Vec_IntClear( vNodes );
//    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_ManCollectAnds_rec( p, Gia_ObjFanin0(pObj), vNodes );
        else
            Gia_ManCollectAnds_rec( p, pObj, vNodes );
    }
}

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

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

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

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 178 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;
}

Vec_Int_t* Gia_ManCollectPoIds

(

Gia_Man_t *

p

)

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

Synopsis [Collects PO Ids into one array.]

Description []

SideEffects []

SeeAlso []

Definition at line 863 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;
}

int Gia_ManCombMarkUsed

(

Gia_Man_t *

p

)

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

int Gia_ManCompare	(	Gia_Man_t *	p1,
		Gia_Man_t *	p2
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1511 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;
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 781 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)];
    }
    Vec_IntFree( vSwitching );
    return SwiTotal;
}

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

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

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

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 351 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;
}

static Gia_Obj_t* Gia_ManConst0 ( Gia_Man_t *  p )

inlinestatic

Definition at line 400 of file gia.h.

{ return p->pObjs;                                                          }

static int Gia_ManConst0Lit ( )

inlinestatic

Definition at line 371 of file gia.h.

{ return 0; }

static Gia_Obj_t* Gia_ManConst1 ( Gia_Man_t *  p )

inlinestatic

Definition at line 401 of file gia.h.

{ return Gia_Not(Gia_ManConst0(p));                                         }

static int Gia_ManConst1Lit ( )

inlinestatic

Definition at line 372 of file gia.h.

{ return 1; }

static int Gia_ManConstrNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 395 of file gia.h.

{ return p->nConstrs;                                                       }

static int Gia_ManCoNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 384 of file gia.h.

{ return Vec_IntSize(p->vCos);                                              }

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

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

int Gia_ManCountChoiceNodes

(

Gia_Man_t *

p

)

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

Synopsis [Counts the number of choice nodes]

Description []

SideEffects []

SeeAlso []

Definition at line 1686 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;
}

int Gia_ManCountChoices

(

Gia_Man_t *

p

)

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

Synopsis [Counts the number of choices]

Description []

SideEffects []

SeeAlso []

Definition at line 1708 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;
}

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

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 262 of file giaCex.c.

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

void Gia_ManCounterExampleValueStart	(	Gia_Man_t *	pGia,
		Abc_Cex_t *	pCex
	)

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 184 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 );
    // 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)) ) );
}

void Gia_ManCounterExampleValueStop

(

Gia_Man_t *

pGia

)

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 242 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;
}

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

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 47 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)++;
    }
}

int* Gia_ManCreateMuxRefs

(

Gia_Man_t *

p

)

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

Synopsis [Assigns references.]

Description []

SideEffects []

SeeAlso []

Definition at line 746 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;
}

void Gia_ManCreateRefs

(

Gia_Man_t *

p

)

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

Synopsis [Assigns references.]

Description []

SideEffects []

SeeAlso []

Definition at line 715 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 );
            Gia_ObjRefFanin1Inc( p, pObj );
            if ( Gia_ObjIsMuxId(p, i) )
                Gia_ObjRefFanin2Inc( p, pObj );
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjRefFanin0Inc( p, pObj );
    }
}

void Gia_ManCreateValueRefs

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 687 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++;
            Gia_ObjFanin1(pObj)->Value++;
        }
        else if ( Gia_ObjIsCo(pObj) )
            Gia_ObjFanin0(pObj)->Value++;
    }
}

int Gia_ManCrossCut	(	Gia_Man_t *	p,
		int	fReverse
	)

Definition at line 820 of file giaUtil.c.

{
    Vec_Int_t * vNodes;
    Gia_Obj_t * pObj;
    int i, nCutCur = 0, nCutMax = 0;
    vNodes = Gia_ManDfsForCrossCut( p, fReverse );
    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;
}

float Gia_ManDelayTraceLut

(

Gia_Man_t *

p

)

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

    // 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;
}

float Gia_ManDelayTraceLutPrint	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 443 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);
    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;
}

int* Gia_ManDeriveNexts

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 97 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 || 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;
}

void Gia_ManDeriveReprs

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 129 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;
    }
}

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

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

Gia_Man_t* Gia_ManDup

(

Gia_Man_t *

p

)

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 552 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;
}

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

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

Synopsis [Computes the AND of all POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2275 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;
}

void Gia_ManDupAppend	(	Gia_Man_t *	pNew,
		Gia_Man_t *	pTwo
	)

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

Synopsis [Appends second AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 746 of file giaDup.c.

{
    Gia_Obj_t * pObj;
    int i;
    if ( pNew->nRegs > 0 )
        pNew->nRegs = 0;
    if ( pNew->pHTable == NULL )
        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) );
    }
}

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

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

Synopsis [Appends logic cones as additional property outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 836 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;
}

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

Definition at line 783 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;
}

void Gia_ManDupAppendShare	(	Gia_Man_t *	p,
		Gia_Man_t *	pTwo
	)

Definition at line 765 of file giaDup.c.

{
    Gia_Obj_t * pObj;
    int i;
    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(pTwo) );
    if ( pNew->pHTable == NULL )
        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) );
    }
}

Gia_Man_t* Gia_ManDupCof	(	Gia_Man_t *	p,
		int	iVar
	)

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

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1319 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;
}

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

Definition at line 1281 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;
}

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

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

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

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

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

Definition at line 748 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;
    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
        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) );
            }
            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 );
            }
        }
        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);
    }
    // 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 );
    assert( Tim_ManPoNum(pManTime) == Gia_ManCoNum(pNew) );
    assert( Tim_ManPiNum(pManTime) == Gia_ManCiNum(pNew) );
    return pNew;
}

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

Definition at line 2691 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 (*)(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 )
        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;

}

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

Definition at line 523 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;
}

Gia_Man_t* Gia_ManDupDfs

(

Gia_Man_t *

p

)

Definition at line 1238 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 )
        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;
}

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

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 1890 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;
}

Gia_Man_t* Gia_ManDupDfsClasses

(

Gia_Man_t *

p

)

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 1940 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;
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1484 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;
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1553 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;
}

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

Definition at line 1528 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;
}

Gia_Man_t* Gia_ManDupDfsSkip

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1454 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;
}

Gia_Man_t* Gia_ManDupExist	(	Gia_Man_t *	p,
		int	iVar
	)

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

Synopsis [Existentially quantified given variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 1360 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;
}

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

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 460 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;
}

Gia_Man_t* Gia_ManDupFlopClass	(	Gia_Man_t *	p,
		int	iClass
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 930 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;
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2853 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;
}

Gia_Man_t* Gia_ManDupLastPis	(	Gia_Man_t *	p,
		int	nLastPis
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 429 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;
}

Gia_Man_t* Gia_ManDupLevelized

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 2812 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;
}

Gia_Man_t* Gia_ManDupMarked

(

Gia_Man_t *

p

)

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 975 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_ObjIsAnd(pObj) && !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(p); 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;
}

Gia_Man_t* Gia_ManDupMuxes	(	Gia_Man_t *	p,
		int	Limit
	)

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

Synopsis [Derives GIA with MUXes.]

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

SideEffects []

SeeAlso []

Definition at line 96 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 >= 2 );
    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;
}

Gia_Man_t* Gia_ManDupNoMuxes

(

Gia_Man_t *

p

)

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

Synopsis [Derives GIA without MUXes.]

Description []

SideEffects []

SeeAlso []

Definition at line 159 of file giaMuxes.c.

{
    Gia_Man_t * pNew, * pTemp;
    Gia_Obj_t * pObj;
    int i;
    assert( p->pMuxes != NULL );
    // 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 = 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;
}

Gia_Man_t* Gia_ManDupNormalize

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 134 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" );
    }
    Gia_ManForEachAnd( p, pObj, i )
        if ( Gia_ObjIsBuf(pObj) )
            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
        else 
            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;
}

Gia_Man_t* Gia_ManDupOneHot

(

Gia_Man_t *

p

)

Definition at line 2785 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;
}

Gia_Man_t* Gia_ManDupOntop	(	Gia_Man_t *	p,
		Gia_Man_t *	p2
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1772 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;
}

Gia_Man_t* Gia_ManDupOrderAiger

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 397 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;
}

Gia_Man_t* Gia_ManDupOrderDfs

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 170 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;
}

Gia_Man_t* Gia_ManDupOrderDfsChoices

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 328 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;
}

Gia_Man_t* Gia_ManDupOrderDfsReverse

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 363 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_ManForEachCoReverse( 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_ManDupRemapCos( pNew, p );
    Gia_ManDupRemapEquiv( pNew, p );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 203 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;
}

Gia_Man_t* Gia_ManDupOutputVec	(	Gia_Man_t *	p,
		Vec_Int_t *	vOutPres
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 232 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;
}

Gia_Man_t* Gia_ManDupPerm	(	Gia_Man_t *	p,
		Vec_Int_t *	vPiPerm
	)

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 632 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_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;
}

Gia_Man_t* Gia_ManDupPermFlop	(	Gia_Man_t *	p,
		Vec_Int_t *	vFfPerm
	)

Definition at line 663 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_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)) ) );
    Vec_IntFree( vPermInv );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

Gia_Man_t* Gia_ManDupPermFlopGap	(	Gia_Man_t *	p,
		Vec_Int_t *	vFfPerm
	)

Definition at line 725 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;
}

void Gia_ManDupRemapEquiv	(	Gia_Man_t *	pNew,
		Gia_Man_t *	p
	)

DECLARATIONS ///.

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

FileName [giaDup.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Duplication procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

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

Synopsis [Removes pointers to the unmarked nodes..]

Description []

SideEffects []

SeeAlso []

Definition at line 46 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 );
}

Gia_Man_t* Gia_ManDupSelectedOutputs	(	Gia_Man_t *	p,
		Vec_Int_t *	vOutsLeft
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 266 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;
}

Gia_Man_t* Gia_ManDupSelf

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 890 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;
}

Gia_Man_t* Gia_ManDupSliced	(	Gia_Man_t *	p,
		int	nSuppMax
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2888 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;
}

Gia_Man_t* Gia_ManDupTimes	(	Gia_Man_t *	p,
		int	nTimes
	)

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

Synopsis [Duplicates AIG while creating "parallel" copies.]

Description []

SideEffects []

SeeAlso []

Definition at line 1078 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;
}

Gia_Man_t* Gia_ManDupTopAnd	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

Synopsis [Detect topmost gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 2075 of file giaDup.c.

{
    Gia_Man_t * pNew, * pTemp;
    int fContinue, iIter = 0;
    pNew = Gia_ManDupNormalize( p );
    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;
}

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1638 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;
}

Gia_Man_t* Gia_ManDupUnnormalize

(

Gia_Man_t *

p

)

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

Synopsis [Duplicates AIG according to the timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 373 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;
}

Gia_Man_t* Gia_ManDupUnshuffleInputs

(

Gia_Man_t *

p

)

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

Synopsis [Reorders flops for sequential AIGs with boxes.]

Description []

SideEffects []

SeeAlso []

Definition at line 194 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;
}

Gia_Man_t* Gia_ManDupWithAttributes

(

Gia_Man_t *

p

)

Definition at line 583 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;
    return pNew;
}

Gia_Man_t* Gia_ManDupWithConstraints	(	Gia_Man_t *	p,
		Vec_Int_t *	vPoTypes
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 2627 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;
}

Gia_Man_t* Gia_ManDupWithNewPo	(	Gia_Man_t *	p1,
		Gia_Man_t *	p2
	)

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

Synopsis [Duplicates transition relation from p1 and property from p2.]

Description []

SideEffects []

SeeAlso []

Definition at line 1816 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;
}

Gia_Man_t* Gia_ManDupZero

(

Gia_Man_t *

p

)

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

Synopsis [Duplicates AIG without any changes.]

Description []

SideEffects []

SeeAlso []

Definition at line 608 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;
}

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

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

Synopsis [Performs 'zero' and 'undc' operation.]

Description [The init string specifies 0/1/X for each flop.]

SideEffects []

SeeAlso []

Definition at line 2390 of file giaDup.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int CountPis = Gia_ManPiNum(p), * pPiLits;
    int i, iResetFlop = -1, Count1 = 0;
    // 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 );
    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 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_ManForEachRo( p, pObj, i )
    {
        if ( pInit[i] == '1' )
            pObj->Value = Abc_LitNot(pObj->Value), Count1++;
        else if ( pInit[i] == 'x' || pInit[i] == 'X' )
            pObj->Value = Gia_ManAppendMux( pNew, iResetFlop, pObj->Value, Gia_Obj2Lit(pNew, Gia_ManPi(pNew, pPiLits[i])) );
        else if ( pInit[i] != '0' )
            assert( 0 );
    }
    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;
}

int Gia_ManEquivCountClasses

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 179 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;
}

int Gia_ManEquivCountLits

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 253 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;
}

int Gia_ManEquivCountLitsAll

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 160 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;
}

void Gia_ManEquivFixOutputPairs

(

Gia_Man_t *

p

)

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 480 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;
    }
}

void Gia_ManEquivImprove

(

Gia_Man_t *

p

)

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

Synopsis [Transforms equiv classes by setting a good representative.]

Description []

SideEffects []

SeeAlso []

Definition at line 1375 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 );
}

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

Definition at line 304 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 );
    assert( Gia_ManEquivCheckLits( p, nLits ) );
    if ( fVerbose )
    {
//        int Ent;
        Abc_Print( 1, "Const0 = " );
        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" );
            }
*/
    }
}

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

Definition at line 292 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" );
}

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

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 417 of file giaEquiv.c.

{
    Gia_Man_t * pNew;
    Gia_Obj_t * pObj;
    int i;
    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;
    }
/*
    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 )
        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
    Gia_ManHashStop( pNew );
    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
    return pNew;
}

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

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

Synopsis [Reduces AIG while remapping equivalence classes.]

Description [Drops the pairs of outputs if they are proved equivalent.]

SideEffects []

SeeAlso []

Definition at line 638 of file giaEquiv.c.

{
    Gia_Man_t * pNew, * pFinal;
    pNew = Gia_ManEquivReduce( p, 0, 0, 0, 0 );
    if ( pNew == NULL )
        return NULL;
    if ( fMiterPairs )
        Gia_ManEquivFixOutputPairs( pNew );
    if ( fSeq )
        Gia_ManSeqMarkUsed( pNew );
    else
        Gia_ManCombMarkUsed( pNew );
    Gia_ManEquivUpdatePointers( p, pNew );
    pFinal = Gia_ManDupMarked( pNew );
    Gia_ManEquivDeriveReprs( p, pNew, pFinal );
    Gia_ManStop( pNew );
    pFinal = Gia_ManEquivRemapDfs( pNew = pFinal );
    Gia_ManStop( pNew );
    return pFinal;
}

int Gia_ManEquivSetColors	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

Synopsis [Marks CIs/COs/ANDs unreachable from POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 692 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;
}

Gia_Man_t* Gia_ManEquivToChoices	(	Gia_Man_t *	p,
		int	nSnapshots
	)

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1629 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++ )
        Gia_ObjSetRepr( pNew, i, 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;
}

void Gia_ManEquivTransform	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

Synopsis [Transforms equiv classes by removing the AB nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1114 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 );
}

float Gia_ManEvaluateSwitching

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 719 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;
}

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

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

void Gia_ManFanoutStart

(

Gia_Man_t *

p

)

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

void Gia_ManFanoutStop

(

Gia_Man_t *

p

)

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

void Gia_ManFillValue

(

Gia_Man_t *

p

)

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

Synopsis [Cleans the value.]

Description []

SideEffects []

SeeAlso []

Definition at line 328 of file giaUtil.c.

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

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

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1862 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 );
    if ( pGia1 == NULL )
    {
        Abc_Print( 1, "Cannot read first file %s.\n", pName1 );
        return 0;
    }
    pGia2 = Gia_AigerRead( pName2, 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;
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2147 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 );
}

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

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1999 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 );
    if ( pGia1 == NULL )
    {
        Abc_Print( 1, "Cannot read first file %s.\n", pName1 );
        return 0;
    }
    pGia2 = Gia_AigerRead( pName2, 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;
}

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

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

Synopsis [Resimulates the counter-example.]

Description []

SideEffects []

SeeAlso []

Definition at line 87 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;
}

Vec_Int_t* Gia_ManFirstFanouts

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1635 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;
}

static void Gia_ManFlipVerbose ( Gia_Man_t *  p )

inlinestatic

Definition at line 396 of file gia.h.

{ p->fVerbose ^= 1;                                                         } 

Gia_Man_t* Gia_ManFraigSweepSimple	(	Gia_Man_t *	p,
		void *	pPars
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 556 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;
}

Gia_Man_t* Gia_ManFrames	(	Gia_Man_t *	pAig,
		Gia_ParFra_t *	pPars
	)

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

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

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

void Gia_ManFraSetDefaultParams

(

Gia_ParFra_t *

p

)

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
}

Gia_Man_t* Gia_ManFront

(

Gia_Man_t *

p

)

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

void Gia_ManFrontTest

(

Gia_Man_t *

p

)

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

Vec_Int_t* Gia_ManGetCiLevels

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels using CI level information.]

Description []

SideEffects []

SeeAlso []

Definition at line 546 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;
}

Vec_Int_t* Gia_ManGetDangling

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has dangling nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1224 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;
}

static int Gia_ManHasCellMapping ( Gia_Man_t *  p )

inlinestatic

Definition at line 959 of file gia.h.

{ return p->vCellMapping != NULL;                                               }

static int Gia_ManHasChoices ( Gia_Man_t *  p )

inlinestatic

Definition at line 397 of file gia.h.

{ return p->pSibls != NULL;                                                 } 

int Gia_ManHasDangling

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has dangling nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1155 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;
}

void Gia_ManHashAlloc

(

Gia_Man_t *

p

)

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

Synopsis [Starts the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 99 of file giaHash.c.

{
    assert( p->pHTable == NULL );
    p->nHTable = Abc_PrimeCudd( Gia_ManAndNum(p) ? Gia_ManAndNum(p) + 1000 : p->nObjsAlloc );
    p->pHTable = ABC_CALLOC( int, p->nHTable );
}

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

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

Synopsis [Hashes AND gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 572 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->nObjs & 0xFF) == 0 && 2 * p->nHTable < 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 *pPlace;
        }
        p->nHashMiss++;
        if ( p->nObjs < p->nObjsAlloc )
            return *pPlace = Gia_ManAppendAnd( p, iLit0, iLit1 );
        else
        {
            int iNode = Gia_ManAppendAnd( p, iLit0, iLit1 );
            pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
            assert( *pPlace == 0 );
            return *pPlace = iNode;
        }
    }
}

int Gia_ManHashAndMulti	(	Gia_Man_t *	p,
		Vec_Int_t *	vLits
	)

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

Synopsis [Creates well-balanced AND gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 763 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);
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 627 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 *pPlace;
        return -1;
    }
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 79 of file giaHash.c.

{
    int iLit0 = Gia_ObjToLit( p, p0 );
    int iLit1 = Gia_ObjToLit( p, p1 );
    if ( iLit0 > iLit1 )
        iLit0 ^= iLit1, iLit1 ^= iLit0, iLit0 ^= iLit1;
    return *Gia_ManHashFind( p, iLit0, iLit1, -1 );
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 700 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 );
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 677 of file giaHash.c.

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

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

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

Synopsis [Hashes MUX gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 517 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_LitNotCond( *pPlace, fCompl );
        }
        p->nHashMiss++;
        if ( p->nObjs < p->nObjsAlloc )
            *pPlace = 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 = iNode;
        }
        return Abc_LitNotCond( *pPlace, fCompl );
    }
}

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

Definition at line 611 of file giaHash.c.

{ 
    return Abc_LitNot(Gia_ManHashAnd( p, Abc_LitNot(iLit0), Abc_LitNot(iLit1) ));
}

void Gia_ManHashProfile

(

Gia_Man_t *

p

)

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

Synopsis [Profiles the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file giaHash.c.

{
    Gia_Obj_t * pEntry;
    int i, Counter, Limit;
    printf( "Table size = %d. Entries = %d. ", p->nHTable, Gia_ManAndNum(p) );
    printf( "Hits = %d. Misses = %d.\n", (int)p->nHashHit, (int)p->nHashMiss );
    Limit = Abc_MinInt( 1000, p->nHTable );
    for ( i = 0; i < Limit; i++ )
    {
        Counter = 0;
        for ( pEntry = (p->pHTable[i]? Gia_ManObj(p, Abc_Lit2Var(p->pHTable[i])) : NULL); 
              pEntry; 
              pEntry = (pEntry->Value? Gia_ManObj(p, Abc_Lit2Var(pEntry->Value)) : NULL) )
            Counter++;
        if ( Counter ) 
            printf( "%d ", Counter );
    }
    printf( "\n" );
}

void Gia_ManHashStart

(

Gia_Man_t *

p

)

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

Synopsis [Starts the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 117 of file giaHash.c.

{
    Gia_Obj_t * pObj;
    int * pPlace, i;
    Gia_ManHashAlloc( p );
    Gia_ManCleanValue( 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 = Abc_Var2Lit( i, 0 );
    }
}

void Gia_ManHashStop

(

Gia_Man_t *

p

)

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

Synopsis [Stops the hash table.]

Description []

SideEffects []

SeeAlso []

Definition at line 142 of file giaHash.c.

{
    ABC_FREE( p->pHTable );
    p->nHTable = 0;
}

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

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 658 of file giaHash.c.

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

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

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

Synopsis [Hashes XOR gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 465 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 * p->nHTable < 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_LitNotCond( *pPlace, fCompl );
        }
        p->nHashMiss++;
        if ( p->nObjs < p->nObjsAlloc )
            *pPlace = Gia_ManAppendXorReal( p, iLit0, iLit1 );
        else
        {
            int iNode = Gia_ManAppendXorReal( p, iLit0, iLit1 );
            pPlace = Gia_ManHashFind( p, iLit0, iLit1, -1 );
            assert( *pPlace == 0 );
            *pPlace = iNode;
        }
        return Abc_LitNotCond( *pPlace, fCompl );
    }
}

static int Gia_ManHasMapping ( Gia_Man_t *  p )

inlinestatic

Definition at line 951 of file gia.h.

{ return p->vMapping != NULL;                                                   }

static int Gia_ManIdToCioId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 437 of file gia.h.

{ return Gia_ObjCioId( Gia_ManObj(p, Id) );                   }

void Gia_ManIncrementTravId

(

Gia_Man_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 149 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++;                                                    
}

void Gia_ManInvertConstraints

(

Gia_Man_t *

pAig

)

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

Synopsis [Complements the constraint outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1415 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 );
}

void Gia_ManInvertPos

(

Gia_Man_t *

pAig

)

Definition at line 1425 of file giaUtil.c.

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

static int Gia_ManIsConst0Lit ( int  iLit )

inlinestatic

Definition at line 373 of file gia.h.

{ return (iLit == 0); }

static int Gia_ManIsConst1Lit ( int  iLit )

inlinestatic

Definition at line 374 of file gia.h.

{ return (iLit == 1); }

static int Gia_ManIsConstLit ( int  iLit )

inlinestatic

Definition at line 375 of file gia.h.

{ return (iLit <= 1); }

int Gia_ManIsNormalized

(

Gia_Man_t *

p

)

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

Synopsis [Makes sure the manager is normalized.]

Description []

SideEffects []

SeeAlso []

Definition at line 109 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;
}

Gia_Man_t* Gia_ManIsoCanonicize	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

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
	)

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

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
	)

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

int Gia_ManIsSeqWithBoxes

(

Gia_Man_t *

p

)

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

Synopsis [Returns one if this is a seq AIG with non-trivial boxes.]

Description []

SideEffects []

SeeAlso []

Definition at line 93 of file giaTim.c.

{
    return (Gia_ManRegNum(p) > 0 && Gia_ManBoxNum(p) > 0);
}

Vec_Vec_t* Gia_ManLevelize

(

Gia_Man_t *

p

)

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

Synopsis [Levelizes the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 379 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;
}

int Gia_ManLevelNum

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 505 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 ( 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;
}

int Gia_ManLevelWithBoxes

(

Gia_Man_t *

p

)

Definition at line 469 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;
}

void Gia_ManLoadValue	(	Gia_Man_t *	p,
		Vec_Int_t *	vValues
	)

Definition at line 1615 of file giaUtil.c.

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

int Gia_ManLutFaninCount

(

Gia_Man_t *

p

)

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 106 of file giaIf.c.

{
    int i, Counter = 0;
    Gia_ManForEachLut( p, i )
        Counter += Gia_ObjLutSize(p, i);
    return Counter;
}

int Gia_ManLutLevel

(

Gia_Man_t *

p

)

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 163 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 )
        if ( Level < pLevels[Gia_ObjFaninId0p(p, pObj)] )
            Level = pLevels[Gia_ObjFaninId0p(p, pObj)];
    ABC_FREE( pLevels );
    return Level;
}

int Gia_ManLutLevelWithBoxes

(

Gia_Man_t *

p

)

Definition at line 572 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 );
    // 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;
}

int Gia_ManLutNum

(

Gia_Man_t *

p

)

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 144 of file giaIf.c.

{
    int i, Counter = 0;
    Gia_ManForEachLut( p, i )
        Counter ++;
    return Counter;
}

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

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 195 of file giaIf.c.

{
    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;
        Gia_ManForEachLut( p, i )
        {
            int Level = 0;
            (*pnCurLuts)++;
            (*pnCurEdges) += Gia_ObjLutSize(p, i);
            Gia_LutForEachFanin( p, i, iFan, k )
                if ( Level < pLevels[iFan] )
                    Level = pLevels[iFan];
            pLevels[i] = Level + 1;
        }
        *pnCurLevels = 0;
        Gia_ManForEachCo( p, pObj, k )
            if ( *pnCurLevels < pLevels[Gia_ObjFaninId0p(p, pObj)] )
                *pnCurLevels = pLevels[Gia_ObjFaninId0p(p, pObj)];
        ABC_FREE( pLevels );
    }
}

int Gia_ManLutSizeMax

(

Gia_Man_t *

p

)

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 125 of file giaIf.c.

{
    int i, nSizeMax = -1;
    Gia_ManForEachLut( p, i )
        nSizeMax = Abc_MaxInt( nSizeMax, Gia_ObjLutSize(p, i) );
    return nSizeMax;
}

void Gia_ManMappingVerify

(

Gia_Man_t *

p

)

Definition at line 1807 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: CO 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" );
}

Gia_Man_t* Gia_ManMapShrink4	(	Gia_Man_t *	p,
		int	fKeepLevel,
		int	fVerbose
	)

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

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

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

int Gia_ManMarkDangling

(

Gia_Man_t *

p

)

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

Synopsis [Returns 1 if AIG has dangling nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1193 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;
}

void Gia_ManMarkFanoutDrivers

(

Gia_Man_t *

p

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1553 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;
    }
}

double Gia_ManMemory

(

Gia_Man_t *

p

)

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

Synopsis [Returns memory used in megabytes.]

Description []

SideEffects []

SeeAlso []

Definition at line 156 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) * p->nHTable * (p->pHTable != NULL);
    return Memory;
}

Gia_Man_t* Gia_ManMiter	(	Gia_Man_t *	p0,
		Gia_Man_t *	p1,
		int	nInsDup,
		int	fDualOut,
		int	fSeq,
		int	fImplic,
		int	fVerbose
	)

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

Synopsis [Creates miter of two designs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2128 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 );
    Gia_ManStop( pTemp );
    return pNew;
}

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

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

Synopsis [Creates miter of two designs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2462 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), 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;
}

static int Gia_ManMuxNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 391 of file gia.h.

{ return p->nMuxes;                                                         }

static char* Gia_ManName ( Gia_Man_t *  p )

inlinestatic

Definition at line 382 of file gia.h.

{ return p->pName;                                                          }

int Gia_ManNonRegBoxNum

(

Gia_Man_t *

p

)

Definition at line 57 of file giaTim.c.

{
    return Gia_ManBoxNum(p) - Gia_ManRegBoxNum(p);
}

static Gia_Obj_t* Gia_ManObj ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 402 of file gia.h.

{ assert( v >= 0 && v < p->nObjs ); return p->pObjs + v;                    }

static int Gia_ManObjIsConst0 ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 431 of file gia.h.

{ return pObj == p->pObjs;                        } 

static int Gia_ManObjNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 388 of file gia.h.

{ return p->nObjs;                                                          }

Vec_Int_t* Gia_ManOrderReverse

(

Gia_Man_t *

p

)

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 407 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;
}

static void Gia_ManPatchCoDriver ( Gia_Man_t *  p, int  iCoIndex, int  iLit0  )

inlinestatic

Definition at line 739 of file gia.h.

{
    Gia_Obj_t * pObjCo  = Gia_ManCo( p, iCoIndex );
    assert( Gia_ObjId(p, pObjCo) > Abc_Lit2Var(iLit0) );
    pObjCo->iDiff0  = Gia_ObjId(p, pObjCo) - Abc_Lit2Var(iLit0);
    pObjCo->fCompl0 = Abc_LitIsCompl(iLit0);
}

Gia_Man_t* Gia_ManPerformBidec	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

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

Definition at line 2058 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;
}

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

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

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

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 451 of file giaFx.c.

{
    extern int Fx_FastExtract( Vec_Wec_t * vCubes, int ObjIdMax, int nNewNodesMax, int LitCountMax, int fVerbose, int fVeryVerbose );
    Gia_Man_t * pNew = NULL;
    Vec_Wec_t * vCubes;
    Vec_Str_t * vCompl;
//    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, 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;
}

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

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

Synopsis [Interface of LUT mapping package.]

Description []

SideEffects []

SeeAlso []

Definition at line 2243 of file giaLf.c.

{
    Gia_Man_t * pNew;
    // 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 );
    Gia_ManTransferMapping( pNew, p );
//    Gia_ManTransferPacking( pNew, p );
    Gia_ManTransferTiming( pNew, p );
    Gia_ManStop( p );
    return pNew;
}

Gia_Man_t* Gia_ManPerformMapping	(	Gia_Man_t *	p,
		void *	pIfPars
	)

Definition at line 1986 of file giaIf.c.

{
    Gia_Man_t * pNew;
    if ( p->pManTime && Tim_ManBoxNum(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 );
        Gia_ManTransferMapping( pNew, p );
        Gia_ManTransferPacking( pNew, p );
        Gia_ManTransferTiming( pNew, p );
        Gia_ManStop( p );
        assert( Gia_ManIsNormalized(pNew) );
    }
    else 
    {
        // mapping
        pNew = Gia_ManPerformMappingInt( p, (If_Par_t *)pp );
        Gia_ManTransferTiming( pNew, p );
    }
    return pNew;
}

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

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

Synopsis [Interface of other mapping-based procedures.]

Description []

SideEffects []

SeeAlso []

Definition at line 2031 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;
}

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

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

static Gia_Obj_t* Gia_ManPi ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 405 of file gia.h.

{ assert( v < Gia_ManPiNum(p) );  return Gia_ManCi( p, v );                 }

static int Gia_ManPiNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 385 of file gia.h.

{ return Vec_IntSize(p->vCis) - p->nRegs;                                   }

static Gia_Obj_t* Gia_ManPo ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 406 of file gia.h.

{ assert( v < Gia_ManPoNum(p) );  return Gia_ManCo( p, v );                 }

static int Gia_ManPoIsConst0 ( Gia_Man_t *  p, int  iPoIndex  )

inlinestatic

Definition at line 475 of file gia.h.

{ return Gia_ManIsConst0Lit( Gia_ObjFaninLit0p(p, Gia_ManPo(p, iPoIndex)) ); }

static int Gia_ManPoIsConst1 ( Gia_Man_t *  p, int  iPoIndex  )

inlinestatic

Definition at line 476 of file gia.h.

{ return Gia_ManIsConst1Lit( Gia_ObjFaninLit0p(p, Gia_ManPo(p, iPoIndex)) ); }

static int Gia_ManPoNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 386 of file gia.h.

{ return Vec_IntSize(p->vCos) - p->nRegs;                                   }

void Gia_ManPrint

(

Gia_Man_t *

p

)

Definition at line 1329 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 );
}

void Gia_ManPrintCo	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj
	)

Definition at line 1349 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 );
}

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

Definition at line 1368 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 );
}

void Gia_ManPrintCone2	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj
	)

Definition at line 1392 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 );
}

void Gia_ManPrintFanio	(	Gia_Man_t *	pGia,
		int	nNodes
	)

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

void Gia_ManPrintLutStats

(

Gia_Man_t *

p

)

Definition at line 613 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 );
}

void Gia_ManPrintMappingStats	(	Gia_Man_t *	p,
		char *	pDumpFile
	)

Definition at line 423 of file giaIf.c.

{
    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) )
        {
            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", p->pName );
            fprintf( pTable, "\n" );
            fprintf( pTable, "%s  ", p->pName );
//            fprintf( pTable, "%d ", Gia_ManCiNum(p) );
//            fprintf( pTable, "%d ", Gia_ManCoNum(p) );
//            fprintf( pTable, "%d  ", Gia_ManAndNum(p) );
            fprintf( pTable, "%d ", Gia_ManPiNum(p) - Gia_ManBoxCiNum(p) - Gia_ManRegBoxNum(p) );
            fprintf( pTable, "%d ", Gia_ManPoNum(p) - Gia_ManBoxCoNum(p) - Gia_ManRegBoxNum(p) );
            fprintf( pTable, "%d ", Gia_ManClockDomainNum(p) );

            fprintf( pTable, " " );
            fprintf( pTable, "%d ", nLuts           );
            fprintf( pTable, "%d ", LevelMax        );
            fprintf( pTable, "%d ", Gia_ManRegBoxNum(p) );
            fprintf( pTable, "%d ", Gia_ManNonRegBoxNum(p) );
            clk = Abc_Clock();
        }
        else
        {
            fprintf( pTable, " " );
            fprintf( pTable, "%d ", nLuts           );
            fprintf( pTable, "%d ", LevelMax        );
            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 );
    }

}

void Gia_ManPrintMiterStatus

(

Gia_Man_t *

p

)

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 543 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 );
}

void Gia_ManPrintMuxStats

(

Gia_Man_t *

p

)

Definition at line 61 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 );
}

void Gia_ManPrintNpnClasses

(

Gia_Man_t *

p

)

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

Synopsis [Prints NPN class statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 668 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;
    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 )
    {
        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 = 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, "Class %3d :  Count = %6d   (%7.2f %%)   %s\n", 
            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) );
    ABC_FREE( pLutClass );
}

Vec_Flt_t* Gia_ManPrintOutputProb

(

Gia_Man_t *

p

)

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

Synopsis [Determine probability of being 1 at the outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 813 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;
}

void Gia_ManPrintPackingStats

(

Gia_Man_t *

p

)

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

Synopsis [Prints mapping statistics.]

Description []

SideEffects []

SeeAlso []

Definition at line 553 of file giaIf.c.

{
    int fVerbose = 0;
    int nObjToShow = 200;
    int nNumStr[5] = {0};
    int i, k, Entry, nEntries, nEntries2, MaxSize = -1;
    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] );
    Abc_Print( 1, "Total = %d", nEntries2 );
    Abc_Print( 1, "\n" );
}

void Gia_ManPrintStats	(	Gia_Man_t *	p,
		Gps_Par_t *	pPars
	)

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 389 of file giaMan.c.

{
    extern float Gia_ManLevelAve( Gia_Man_t * p );
    if ( pPars && pPars->fMiter )
    {
        Gia_ManPrintStatsMiter( p, 0 );
        return;
    }
#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) );

#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, " (%.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
    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 ( Gia_ManBufNum(p) )
        Abc_Print( 1, "  buf = %d", Gia_ManBufNum(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 );
    if ( pPars && pPars->fNpn && Gia_ManHasMapping(p) && Gia_ManLutSizeMax(p) <= 4 )
        Gia_ManPrintNpnClasses( p );
    if ( p->vPacking )
        Gia_ManPrintPackingStats( 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 );
    }
}

void Gia_ManPrintStatsMiter	(	Gia_Man_t *	p,
		int	fVerbose
	)

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

Synopsis [Statistics of the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 594 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 );
}

void Gia_ManPrintStatsShort

(

Gia_Man_t *

p

)

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 522 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" );
}

unsigned Gia_ManRandom

(

int

fReset

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates a sequence or random numbers.]

Description []

SideEffects []

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

Definition at line 49 of file giaUtil.c.

{
    static unsigned int m_z = NUMBER1;
    static unsigned int m_w = NUMBER2;
    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;
}

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

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

Synopsis [Creates random info for the primary inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 80 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);
}

word Gia_ManRandomW

(

int

fReset

)

Definition at line 62 of file giaUtil.c.

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

Gia_Man_t* Gia_ManReadMiniAig

(

char *

pFileName

)

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

Synopsis [Procedures to read/write GIA to/from MiniAIG file.]

Description []

SideEffects []

SeeAlso []

Definition at line 167 of file giaMini.c.

{
    Mini_Aig_t * p = Mini_AigLoad( pFileName );
    Gia_Man_t * pGia = Gia_ManFromMiniAig( p );
    ABC_FREE( pGia->pName );
    pGia->pName = Extra_FileNameGeneric( pFileName ); 
    Mini_AigStop( p );
    return pGia;
}

Gia_Man_t* Gia_ManReduceConst	(	Gia_Man_t *	pAig,
		int	fVerbose
	)

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

int Gia_ManRegBoxNum

(

Gia_Man_t *

p

)

Definition at line 53 of file giaTim.c.

{
    return p->vRegClasses ? Vec_IntSize(p->vRegClasses) : 0;
}

static int Gia_ManRegNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 387 of file gia.h.

{ return p->nRegs;                                                          }

Gia_Man_t* Gia_ManRehash	(	Gia_Man_t *	p,
		int	fAddStrash
	)

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

Synopsis [Rehashes AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 719 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;
}

Gia_Man_t* Gia_ManRemoveEnables

(

Gia_Man_t *

p

)

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, * 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;
}

void Gia_ManReportImprovement	(	Gia_Man_t *	p,
		Gia_Man_t *	pNew
	)

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

Synopsis [Reports the reduction of the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 646 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" );
}

Vec_Int_t* Gia_ManRequiredLevel

(

Gia_Man_t *

p

)

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

Synopsis [Compute required levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 639 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;
}

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

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

Vec_Int_t* Gia_ManReverseLevel

(

Gia_Man_t *

p

)

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

Synopsis [Compute reverse levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 595 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;
}

static Gia_Obj_t* Gia_ManRi ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 408 of file gia.h.

{ assert( v < Gia_ManRegNum(p) ); return Gia_ManCo( p, Gia_ManPoNum(p)+v ); }

static Gia_Obj_t* Gia_ManRo ( Gia_Man_t *  p, int  v  )

inlinestatic

Definition at line 407 of file gia.h.

{ assert( v < Gia_ManRegNum(p) ); return Gia_ManCi( p, Gia_ManPiNum(p)+v ); }

Vec_Int_t* Gia_ManSaveValue

(

Gia_Man_t *

p

)

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

Synopsis [Save/load value from file.]

Description []

SideEffects []

SeeAlso []

Definition at line 1605 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_Man_t* Gia_ManSeqCleanup

(

Gia_Man_t *

p

)

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

Synopsis [Performs sequential cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 183 of file giaScl.c.

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

int Gia_ManSeqMarkUsed

(

Gia_Man_t *

p

)

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

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

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

int Gia_ManSetFailedPoCex	(	Gia_Man_t *	pAig,
		Abc_Cex_t *	p
	)

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

Synopsis [Determines the failed PO when its exact frame is not known.]

Description []

SideEffects []

SeeAlso []

Definition at line 135 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;
}

void Gia_ManSetIfParsDefault

(

void *

pp

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Load the network into FPGA manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 57 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;   
}

int Gia_ManSetLevels	(	Gia_Man_t *	p,
		Vec_Int_t *	vCiLevels
	)

Definition at line 558 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;
}

void Gia_ManSetMark0

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 196 of file giaUtil.c.

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

void Gia_ManSetMark1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 253 of file giaUtil.c.

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

void Gia_ManSetPhase

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 379 of file giaUtil.c.

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

void Gia_ManSetPhase1

(

Gia_Man_t *

p

)

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

Synopsis [Sets phases of the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 409 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 );
}

void Gia_ManSetPhasePattern	(	Gia_Man_t *	p,
		Vec_Int_t *	vCiValues
	)

Definition at line 386 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 );
}

void Gia_ManSetRefsMapped

(

Gia_Man_t *

p

)

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

Synopsis [Assigns levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 245 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_ObjRefInc( p, Gia_ObjFanin0(pObj) );
    Gia_ManForEachLut( p, i )
        Gia_LutForEachFanin( p, i, iFan, k )
            Gia_ObjRefInc( p, Gia_ManObj(p, iFan) );
}

void Gia_ManSetRegNum	(	Gia_Man_t *	p,
		int	nRegs
	)

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

Synopsis [Prints stats for the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 628 of file giaMan.c.

{
    assert( p->nRegs == 0 );
    p->nRegs = nRegs;
}

void Gia_ManSimInfoInit

(

Gia_ManSim_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 429 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) );
    }
}

void Gia_ManSimInfoTransfer

(

Gia_ManSim_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 452 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)) );
    }
}

void Gia_ManSimSetDefaultParams

(

Gia_ParSim_t *

p

)

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

Synopsis [This procedure sets default parameters.]

Description []

SideEffects []

SeeAlso []

Definition at line 164 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
}

int Gia_ManSimSimulate	(	Gia_Man_t *	pAig,
		Gia_ParSim_t *	pPars
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 598 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;
}

void Gia_ManSimulateRound

(

Gia_ManSim_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 475 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 );
}

void Gia_ManSolveProblem	(	Gia_Man_t *	pGia,
		Emb_Par_t *	pPars
	)

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

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

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

Synopsis [Reduces AIG using equivalence classes.]

Description []

SideEffects []

SeeAlso []

Definition at line 848 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;
}

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

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

Synopsis [Creates initialized SRM with the given number of frames.]

Description []

SideEffects []

SeeAlso []

Definition at line 985 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;
}

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

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 1075 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;
}

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

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

Synopsis [Adds choices to speed up the network by the given percentage.]

Description []

SideEffects []

SeeAlso []

Definition at line 628 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;
}

Gia_Man_t* Gia_ManStart

(

int

nObjsMax

)

DECLARATIONS ///.

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

FileName [giaMan.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [Package manager.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:

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

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

Synopsis [Creates AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 52 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;
}

void Gia_ManStaticFanoutStart

(

Gia_Man_t *

p

)

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

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

void Gia_ManStaticFanoutStop

(

Gia_Man_t *

p

)

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

Synopsis [Deallocates static fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 290 of file giaFanout.c.

{
    Vec_IntFreeP( &p->vFanoutNums );
    Vec_IntFreeP( &p->vFanout );
}

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

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

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

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

void Gia_ManStop

(

Gia_Man_t *

p

)

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

Synopsis [Deletes AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 77 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_IntFreeP( &p->vSwitching );
    Vec_IntFreeP( &p->vSuper );
    Vec_IntFreeP( &p->vStore );
    Vec_IntFreeP( &p->vClassNew );
    Vec_IntFreeP( &p->vClassOld );
    Vec_WrdFreeP( &p->vSims );
    Vec_WrdFreeP( &p->vSimsPi );
    Vec_FltFreeP( &p->vTiming );
    Vec_VecFreeP( &p->vClockDoms );
    Vec_IntFreeP( &p->vCofVars );
    Vec_IntFreeP( &p->vLutConfigs );
    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->vDoms );
    Vec_IntFreeP( &p->vBarBufs );
    Vec_IntFreeP( &p->vLevels );
    Vec_IntFreeP( &p->vTruths );
    Vec_IntErase( &p->vCopies );
    Vec_IntFreeP( &p->vTtNums );
    Vec_IntFreeP( &p->vTtNodes );
    Vec_WrdFreeP( &p->vTtMemory );
    Vec_PtrFreeP( &p->vTtInputs );
    Vec_IntFreeP( &p->vMapping );
    Vec_IntFreeP( &p->vCellMapping );
    Vec_IntFreeP( &p->vPacking );
    Vec_FltFreeP( &p->vInArrs );
    Vec_FltFreeP( &p->vOutReqs );
    Gia_ManStopP( &p->pAigExtra );
    Vec_IntFree( p->vCis );
    Vec_IntFree( p->vCos );
    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->pNodeRefs );
    ABC_FREE( p->pHTable );
    ABC_FREE( p->pMuxes );
    ABC_FREE( p->pObjs );
    ABC_FREE( p->pSpec );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

void Gia_ManStopP

(

Gia_Man_t **

p

)

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

Synopsis [Stops the AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 177 of file giaMan.c.

{
    if ( *p == NULL )
        return;
    Gia_ManStop( *p );
    *p = NULL;
}

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

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

Synopsis [Collects support nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 300 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;
}

void Gia_ManSwapPos	(	Gia_Man_t *	p,
		int	i
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1582 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 );
}

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

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

Synopsis [Reduces root model with scorr.]

Description []

SideEffects []

SeeAlso []

Definition at line 683 of file giaSweep.c.

{ 
    Gia_Man_t * pClp, * pNew, * pTemp;
    int * pReprs;
    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 );
    // order AIG objects
    pNew = Gia_ManDupUnnormalize( p );
    if ( pNew == NULL )
        return NULL;
    Gia_ManTransferTiming( pNew, p );
    // find global equivalences
    pClp = Gia_ManDupCollapse( pNew, pNew->pAigExtra, NULL, pParsC ? 0 : 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 );
    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 );
    // normalize the result
    pNew = Gia_ManDupNormalize( pTemp = pNew );
    Gia_ManTransferTiming( pNew, pTemp );
    Gia_ManStop( pTemp );
    // check integrity
    //Gia_ManCheckIntegrityWithBoxes( pNew );
    return pNew;
}

void Gia_ManTestDistance

(

Gia_Man_t *

pGia

)

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

static void Gia_ManTimeClean ( Gia_Man_t *  p )

inlinestatic

Definition at line 538 of file gia.h.

{ int i; assert( p->vTiming != NULL ); Vec_FltFill(p->vTiming, 3*Gia_ManObjNum(p), 0); for ( i = 0; i < Gia_ManObjNum(p); i++ )  Vec_FltWriteEntry( p->vTiming, 3*i+1, (float)(ABC_INFINITY) ); }

static void Gia_ManTimeStart ( Gia_Man_t *  p )

inlinestatic

Definition at line 539 of file gia.h.

{ assert( p->vTiming == NULL ); p->vTiming = Vec_FltAlloc(0); Gia_ManTimeClean( p );  }

static void Gia_ManTimeStop ( Gia_Man_t *  p )

inlinestatic

Definition at line 540 of file gia.h.

{ assert( p->vTiming != NULL ); Vec_FltFreeP(&p->vTiming);                            }

void Gia_ManTransferMapping	(	Gia_Man_t *	p,
		Gia_Man_t *	pGia
	)

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

Synopsis [Transfers mapping from hie GIA to normalized GIA.]

Description [Hie GIA (pGia) points to normalized GIA (p).]

SideEffects []

SeeAlso []

Definition at line 1855 of file giaIf.c.

{
    Gia_Obj_t * pObj;
    int i, k, iFan;
    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 )
    {
        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) );
        Vec_IntPush( p->vMapping, Gia_ObjLutSize(pGia, i) );
        Gia_LutForEachFanin( pGia, i, iFan, k )
            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 );
}

void Gia_ManTransferPacking	(	Gia_Man_t *	p,
		Gia_Man_t *	pGia
	)

Definition at line 1878 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;
}

void Gia_ManTransferTiming	(	Gia_Man_t *	p,
		Gia_Man_t *	pGia
	)

Definition at line 1912 of file giaIf.c.

{
    if ( pGia->pManTime == NULL || p == pGia )
        return;
    p->pManTime    = pGia->pManTime;    pGia->pManTime    = NULL;
    p->pAigExtra   = pGia->pAigExtra;   pGia->pAigExtra   = NULL;
    p->vRegClasses = pGia->vRegClasses; pGia->vRegClasses = NULL;
    p->nAnd2Delay  = pGia->nAnd2Delay;  pGia->nAnd2Delay  = 0;
}

Gia_Man_t* Gia_ManTransformMiter

(

Gia_Man_t *

p

)

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

Synopsis [Transforms the circuit into a regular miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 2324 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 );
    return pNew;
}

Gia_Man_t* Gia_ManTransformToDual

(

Gia_Man_t *

p

)

Definition at line 2353 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;
}

static void Gia_ManTruthClear ( unsigned *  pOut, int  nVars  )

inlinestatic

Definition at line 352 of file gia.h.

{
    int w;
    for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
        pOut[w] = 0;
}

static void Gia_ManTruthCopy ( unsigned *  pOut, unsigned *  pIn, int  nVars  )

inlinestatic

Definition at line 346 of file gia.h.

{
    int w;
    for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
        pOut[w] = pIn[w];
}

static void Gia_ManTruthFill ( unsigned *  pOut, int  nVars  )

inlinestatic

Definition at line 358 of file gia.h.

{
    int w;
    for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
        pOut[w] = ~(unsigned)0;
}

static int Gia_ManTruthIsConst0 ( unsigned *  pIn, int  nVars  )

inlinestatic

Definition at line 330 of file gia.h.

{
    int w;
    for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
        if ( pIn[w] )
            return 0;
    return 1;
}

static int Gia_ManTruthIsConst1 ( unsigned *  pIn, int  nVars  )

inlinestatic

Definition at line 338 of file gia.h.

{
    int w;
    for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
        if ( pIn[w] != ~(unsigned)0 )
            return 0;
    return 1;
}

static void Gia_ManTruthNot ( unsigned *  pOut, unsigned *  pIn, int  nVars  )

inlinestatic

Definition at line 364 of file gia.h.

{
    int w;
    for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
        pOut[w] = ~pIn[w];
}

Vec_Ptr_t* Gia_ManUnrollAbs	(	Gia_Man_t *	p,
		int	nFrames
	)

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

void* Gia_ManUnrollAdd	(	void *	pMan,
		int	fMax
	)

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, 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;
}

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

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

Gia_Man_t* Gia_ManUnrollDup	(	Gia_Man_t *	p,
		Vec_Int_t *	vLimit
	)

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

int Gia_ManUnrollLastLit

(

void *

pMan

)

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

void* Gia_ManUnrollStart	(	Gia_Man_t *	pAig,
		Gia_ParFra_t *	pPars
	)

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

void Gia_ManUnrollStop

(

void *

pMan

)

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

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

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

Synopsis [Update AIG of the holes.]

Description []

SideEffects []

SeeAlso []

Definition at line 683 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;
}

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

Definition at line 702 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;
}

void* Gia_ManUpdateTimMan	(	Gia_Man_t *	p,
		Vec_Int_t *	vBoxPres
	)

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

Synopsis [Update hierarchy/timing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 657 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 );
}

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

Definition at line 664 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 );
}

int Gia_ManVerifyCex	(	Gia_Man_t *	pAig,
		Abc_Cex_t *	p,
		int	fDualOut
	)

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 44 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;
}

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

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

Synopsis [Verify XAIG against its spec.]

Description []

SideEffects []

SeeAlso []

Definition at line 859 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 );
    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 );
    }
    // 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;
}

void Gia_ManWriteMiniAig	(	Gia_Man_t *	pGia,
		char *	pFileName
	)

Definition at line 176 of file giaMini.c.

{
    Mini_Aig_t * p = Gia_ManToMiniAig( pGia );
    Mini_AigDump( p, pFileName );
    Mini_AigStop( p );
}

static int Gia_ManXorNum ( Gia_Man_t *  p )

inlinestatic

Definition at line 390 of file gia.h.

{ return p->nXors;                                                          }

char* Gia_MmFixedEntryFetch

(

Gia_MmFixed_t *

p

)

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

void Gia_MmFixedEntryRecycle	(	Gia_MmFixed_t *	p,
		char *	pEntry
	)

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

int Gia_MmFixedReadMaxEntriesUsed

(

Gia_MmFixed_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 287 of file giaMem.c.

{
    return p->nEntriesMax;
}

int Gia_MmFixedReadMemUsage

(

Gia_MmFixed_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 271 of file giaMem.c.

{
    return p->nMemoryAlloc;
}

void Gia_MmFixedRestart

(

Gia_MmFixed_t *

p

)

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_MmFixed_t* Gia_MmFixedStart	(	int	nEntrySize,
		int	nEntriesMax
	)

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

void Gia_MmFixedStop	(	Gia_MmFixed_t *	p,
		int	fVerbose
	)

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

char* Gia_MmFlexEntryFetch	(	Gia_MmFlex_t *	p,
		int	nBytes
	)

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

int Gia_MmFlexReadMemUsage

(

Gia_MmFlex_t *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 439 of file giaMem.c.

{
    return p->nMemoryUsed;
}

void Gia_MmFlexRestart

(

Gia_MmFlex_t *

p

)

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_MmFlex_t* Gia_MmFlexStart

(

)

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

void Gia_MmFlexStop	(	Gia_MmFlex_t *	p,
		int	fVerbose
	)

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

char* Gia_MmStepEntryFetch	(	Gia_MmStep_t *	p,
		int	nBytes
	)

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

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

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

int Gia_MmStepReadMemUsage

(

Gia_MmStep_t *

p

)

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_MmStep_t* Gia_MmStepStart

(

int

nSteps

)

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

void Gia_MmStepStop	(	Gia_MmStep_t *	p,
		int	fVerbose
	)

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

int Gia_NodeMffcSize	(	Gia_Man_t *	p,
		Gia_Obj_t *	pNode
	)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 1132 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 );
    assert( ConeSize1 == ConeSize2 );
    assert( ConeSize1 >= 0 );
    return ConeSize1;
}

static Gia_Obj_t* Gia_Not ( Gia_Obj_t *  p )

inlinestatic

Definition at line 378 of file gia.h.

{ return (Gia_Obj_t *)((ABC_PTRUINT_T)(p) ^  01);                           }

static Gia_Obj_t* Gia_NotCond ( Gia_Obj_t *  p, int  c  )

inlinestatic

Definition at line 379 of file gia.h.

{ return (Gia_Obj_t *)((ABC_PTRUINT_T)(p) ^ (c));                           }

static int Gia_Obj2Lit ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 433 of file gia.h.

{ return Abc_Var2Lit(Gia_ObjId(p, Gia_Regular(pObj)), Gia_IsComplement(pObj)); }

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

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(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;
    }
}

static int Gia_ObjCellFanin ( Gia_Man_t *  p, int  iLit, int  i  )

inlinestatic

Definition at line 965 of file gia.h.

{ return Gia_ObjCellFanins(p, iLit)[i];                                         }

static int* Gia_ObjCellFanins ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 964 of file gia.h.

{ return Vec_IntEntryP(p->vCellMapping, Vec_IntEntry(p->vCellMapping, iLit))+1; }

static int Gia_ObjCellId ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 966 of file gia.h.

{ return Gia_ObjCellFanins(p, iLit)[Gia_ObjCellSize(p, iLit)];                  }

static int Gia_ObjCellSize ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 963 of file gia.h.

{ return Vec_IntEntry(p->vCellMapping, Vec_IntEntry(p->vCellMapping, iLit));    }

static Gia_Obj_t* Gia_ObjChild0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 457 of file gia.h.

{ return Gia_NotCond( Gia_ObjFanin0(pObj), Gia_ObjFaninC0(pObj) ); }

static Gia_Obj_t* Gia_ObjChild1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 458 of file gia.h.

{ return Gia_NotCond( Gia_ObjFanin1(pObj), Gia_ObjFaninC1(pObj) ); }

static Gia_Obj_t* Gia_ObjChild2 ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 459 of file gia.h.

{ return Gia_NotCond( Gia_ObjFanin2(p, pObj), Gia_ObjFaninC2(p, pObj) ); }

static int Gia_ObjCioId ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 411 of file gia.h.

{ assert( pObj->fTerm ); return pObj->iDiff1;                 }

void Gia_ObjCollectInternal	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj
	)

Definition at line 159 of file giaTruth.c.

{
    Vec_IntClear( p->vTtNodes );
    Gia_ObjCollectInternal_rec( p, pObj );
}

static int Gia_ObjColor ( Gia_Man_t *  p, int  Id, int  c  )

inlinestatic

Definition at line 903 of file gia.h.

{ return c? p->pReprs[Id].fColorB : p->pReprs[Id].fColorA;          }

static int Gia_ObjColors ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 904 of file gia.h.

{ return p->pReprs[Id].fColorB * 2 + p->pReprs[Id].fColorA;         }

word* Gia_ObjComputeTruthTable	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj
	)

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

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

Definition at line 116 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 );
}

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

Definition at line 76 of file giaTruth.c.

{
    int i, Fanin;
    assert( Vec_WrdSize(vTemp) == Gia_ManObjNum(p) );
    assert( Gia_ObjIsLut(p, iObj) );
    Gia_LutForEachFanin( p, iObj, Fanin, i )
        Vec_WrdWriteEntry( vTemp, Fanin, s_Truth6[i] );
    assert( i <= 6 );
    Gia_ObjComputeTruthTable6Lut_rec( p, iObj, vTemp );
    return Vec_WrdEntry( vTemp, iObj );
}

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

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 351 of file giaTruth.c.

{
    Gia_Obj_t * pTemp;
    word * pTruth, * pTruthL, * pTruth0, * pTruth1;
    int i, iObj, Id0, Id1;
    assert( p->vTtMemory != NULL );
    assert( Vec_IntSize(vLeaves) <= p->nTtVars );
    // 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;
}

void Gia_ObjComputeTruthTableStart	(	Gia_Man_t *	p,
		int	nVarsMax
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 282 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 );
}

void Gia_ObjComputeTruthTableStop

(

Gia_Man_t *

p

)

Definition at line 293 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 );
}

static Gia_Obj_t* Gia_ObjCopy ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 478 of file gia.h.

{ return Gia_ManObj( p, Abc_Lit2Var(pObj->Value) );                              }

static int Gia_ObjCopyArray ( Gia_Man_t *  p, int  iObj  )

inlinestatic

Definition at line 487 of file gia.h.

{ return Vec_IntEntry(&p->vCopies, iObj);                                          }

static int Gia_ObjCopyF ( Gia_Man_t *  p, int  f, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 485 of file gia.h.

{ return Vec_IntEntry(&p->vCopies, Gia_ManObjNum(p) * f + Gia_ObjId(p,pObj));      }

static unsigned Gia_ObjCutSign ( unsigned  ObjId )

inlinestatic

Definition at line 310 of file gia.h.

{ return (1 << (ObjId & 31));                                 }

static int Gia_ObjDiff0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 449 of file gia.h.

{ return pObj->iDiff0;         }

static int Gia_ObjDiff1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 450 of file gia.h.

{ return pObj->iDiff1;         }

static int Gia_ObjDiffColors ( Gia_Man_t *  p, int  i, int  j  )

inlinestatic

Definition at line 908 of file gia.h.

{ return (p->pReprs[i].fColorA ^ p->pReprs[j].fColorA) && (p->pReprs[i].fColorB ^ p->pReprs[j].fColorB); }

static int Gia_ObjDiffColors2 ( Gia_Man_t *  p, int  i, int  j  )

inlinestatic

Definition at line 909 of file gia.h.

{ return (p->pReprs[i].fColorA ^ p->pReprs[j].fColorA) || (p->pReprs[i].fColorB ^ p->pReprs[j].fColorB); }

static int Gia_ObjFailed ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 900 of file gia.h.

{ return p->pReprs[Id].fFailed;       }

static Gia_Obj_t* Gia_ObjFanin0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 454 of file gia.h.

{ return pObj - pObj->iDiff0;  }

static int Gia_ObjFanin0Copy ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 481 of file gia.h.

{ return Abc_LitNotCond( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) );     }

static int Gia_ObjFanin0CopyArray ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 493 of file gia.h.

{ return Abc_LitNotCond(Gia_ObjCopyArray(p, Gia_ObjFaninId0p(p,pObj)), Gia_ObjFaninC0(pObj));  }

static int Gia_ObjFanin0CopyF ( Gia_Man_t *  p, int  f, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 491 of file gia.h.

{ return Abc_LitNotCond(Gia_ObjCopyF(p, f, Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj));   }

static Gia_Obj_t* Gia_ObjFanin1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 455 of file gia.h.

{ return pObj - pObj->iDiff1;  }

static int Gia_ObjFanin1Copy ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 482 of file gia.h.

{ return Abc_LitNotCond( Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC1(pObj) );     }

static int Gia_ObjFanin1CopyArray ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 494 of file gia.h.

{ return Abc_LitNotCond(Gia_ObjCopyArray(p, Gia_ObjFaninId1p(p,pObj)), Gia_ObjFaninC1(pObj));  }

static int Gia_ObjFanin1CopyF ( Gia_Man_t *  p, int  f, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 492 of file gia.h.

{ return Abc_LitNotCond(Gia_ObjCopyF(p, f, Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj));   }

static Gia_Obj_t* Gia_ObjFanin2 ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 456 of file gia.h.

{ return p->pMuxes ? Gia_ManObj(p, Abc_Lit2Var(p->pMuxes[Gia_ObjId(p, pObj)])) : NULL;  }

static int Gia_ObjFanin2Copy ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 483 of file gia.h.

{ return Abc_LitNotCond(Gia_ObjFanin2(p, pObj)->Value, Gia_ObjFaninC2(p, pObj)); }

static int Gia_ObjFaninC0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 451 of file gia.h.

{ return pObj->fCompl0;        }

static int Gia_ObjFaninC1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 452 of file gia.h.

{ return pObj->fCompl1;        }

static int Gia_ObjFaninC2 ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 453 of file gia.h.

{ return p->pMuxes && Abc_LitIsCompl(p->pMuxes[Gia_ObjId(p, pObj)]);  }

static int Gia_ObjFaninId0 ( Gia_Obj_t *  pObj, int  ObjId  )

inlinestatic

Definition at line 460 of file gia.h.

{ return ObjId - pObj->iDiff0;    }

static int Gia_ObjFaninId0p ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 463 of file gia.h.

{ return Gia_ObjFaninId0( pObj, Gia_ObjId(p, pObj) );              }

static int Gia_ObjFaninId1 ( Gia_Obj_t *  pObj, int  ObjId  )

inlinestatic

Definition at line 461 of file gia.h.

{ return ObjId - pObj->iDiff1;    }

static int Gia_ObjFaninId1p ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 464 of file gia.h.

{ return Gia_ObjFaninId1( pObj, Gia_ObjId(p, pObj) );              }

static int Gia_ObjFaninId2 ( Gia_Man_t *  p, int  ObjId  )

inlinestatic

Definition at line 462 of file gia.h.

{ return (p->pMuxes && p->pMuxes[ObjId]) ? Abc_Lit2Var(p->pMuxes[ObjId]) : -1; }

static int Gia_ObjFaninId2p ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 465 of file gia.h.

{ return (p->pMuxes && p->pMuxes[Gia_ObjId(p, pObj)]) ? Abc_Lit2Var(p->pMuxes[Gia_ObjId(p, pObj)]) : -1; }

static int Gia_ObjFaninLit0 ( Gia_Obj_t *  pObj, int  ObjId  )

inlinestatic

Definition at line 466 of file gia.h.

{ return Abc_Var2Lit( Gia_ObjFaninId0(pObj, ObjId), Gia_ObjFaninC0(pObj) ); }

static int Gia_ObjFaninLit0p ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 469 of file gia.h.

{ return Abc_Var2Lit( Gia_ObjFaninId0p(p, pObj), Gia_ObjFaninC0(pObj) );    }

static int Gia_ObjFaninLit1 ( Gia_Obj_t *  pObj, int  ObjId  )

inlinestatic

Definition at line 467 of file gia.h.

{ return Abc_Var2Lit( Gia_ObjFaninId1(pObj, ObjId), Gia_ObjFaninC1(pObj) ); }

static int Gia_ObjFaninLit1p ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 470 of file gia.h.

{ return Abc_Var2Lit( Gia_ObjFaninId1p(p, pObj), Gia_ObjFaninC1(pObj) );    }

static int Gia_ObjFaninLit2 ( Gia_Man_t *  p, int  ObjId  )

inlinestatic

Definition at line 468 of file gia.h.

{ return (p->pMuxes && p->pMuxes[ObjId]) ? p->pMuxes[ObjId] : -1;           }

static int Gia_ObjFaninLit2p ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 471 of file gia.h.

{ return (p->pMuxes && p->pMuxes[Gia_ObjId(p, pObj)]) ? p->pMuxes[Gia_ObjId(p, pObj)] : -1;    }

static Gia_Obj_t* Gia_ObjFanout ( Gia_Man_t *  p, Gia_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 943 of file gia.h.

{ return Gia_ManObj( p, Gia_ObjFanoutId(p, Gia_ObjId(p, pObj), i) );     }

static Gia_Obj_t* Gia_ObjFanout0 ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 942 of file gia.h.

{ return Gia_ManObj( p, Gia_ObjFanoutId(p, Gia_ObjId(p, pObj), 0) );     }

static int Gia_ObjFanoutId ( Gia_Man_t *  p, int  Id, int  i  )

inlinestatic

Definition at line 941 of file gia.h.

{ return Vec_IntEntry( p->vFanout, Gia_ObjFoffsetId(p, Id) + i );        }

static int Gia_ObjFanoutNum ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 940 of file gia.h.

{ return Gia_ObjFanoutNumId( p, Gia_ObjId(p, pObj) );                    }

static int Gia_ObjFanoutNumId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 939 of file gia.h.

{ return Vec_IntEntry( p->vFanoutNums, Id );                             }

static void Gia_ObjFlipFaninC0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 472 of file gia.h.

{ assert( Gia_ObjIsCo(pObj) ); pObj->fCompl0 ^= 1;          }

static int Gia_ObjFoffset ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 938 of file gia.h.

{ return Gia_ObjFoffsetId( p, Gia_ObjId(p, pObj) );                      }

static int Gia_ObjFoffsetId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 937 of file gia.h.

{ return Vec_IntEntry( p->vFanout, Id );                                 }

static Gia_Obj_t* Gia_ObjFromLit ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 496 of file gia.h.

{ return Gia_NotCond( Gia_ManObj(p, Abc_Lit2Var(iLit)), Abc_LitIsCompl(iLit) );  }

static int Gia_ObjHasNumId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 511 of file gia.h.

{ return Vec_IntEntry(p->vTtNums, Id) > -ABC_INFINITY;     }

static int Gia_ObjHasRepr ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 891 of file gia.h.

{ return p->pReprs[Id].iRepr != GIA_VOID;                                    }

static int Gia_ObjHasSameRepr ( Gia_Man_t *  p, int  i, int  k  )

inlinestatic

Definition at line 920 of file gia.h.

{ assert( k ); return i? (Gia_ObjRepr(p, i) == Gia_ObjRepr(p, k) && Gia_ObjRepr(p, i) != GIA_VOID) : Gia_ObjRepr(p, k) == 0;  }

static int Gia_ObjId ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 410 of file gia.h.

{ assert( p->pObjs <= pObj && pObj < p->pObjs + p->nObjs ); return pObj - p->pObjs; }

static int Gia_ObjIsAnd ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 422 of file gia.h.

{ return!pObj->fTerm && pObj->iDiff0 != GIA_NONE; } 

static int Gia_ObjIsAndNotBuf ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 428 of file gia.h.

{ return Gia_ObjIsAnd(pObj) && pObj->iDiff0 != pObj->iDiff1; } 

static int Gia_ObjIsAndOrConst0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 419 of file gia.h.

{ return!pObj->fTerm;                             } 

static int Gia_ObjIsAndReal ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 426 of file gia.h.

{ return Gia_ObjIsAnd(pObj) && pObj->iDiff0 > pObj->iDiff1 && !Gia_ObjIsMux(p, pObj); } 

static int Gia_ObjIsBuf ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 427 of file gia.h.

{ return pObj->iDiff0 == pObj->iDiff1 && pObj->iDiff0 != GIA_NONE && !pObj->fTerm;    } 

static int Gia_ObjIsCand ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 429 of file gia.h.

{ return Gia_ObjIsAnd(pObj) || Gia_ObjIsCi(pObj); } 

static int Gia_ObjIsCell ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 960 of file gia.h.

{ return Vec_IntEntry(p->vCellMapping, iLit) != 0;                              }

static int Gia_ObjIsCellBuf ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 962 of file gia.h.

{ return Vec_IntEntry(p->vCellMapping, iLit) == -2;                             }

static int Gia_ObjIsCellInv ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 961 of file gia.h.

{ return Vec_IntEntry(p->vCellMapping, iLit) == -1;                             }

static int Gia_ObjIsCi ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 420 of file gia.h.

{ return pObj->fTerm && pObj->iDiff0 == GIA_NONE; } 

static int Gia_ObjIsClass ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 919 of file gia.h.

{ return (Gia_ObjRepr(p, Id) > 0 && Gia_ObjRepr(p, Id) != GIA_VOID) || Gia_ObjNext(p, Id) > 0;                   }

static int Gia_ObjIsCo ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 421 of file gia.h.

{ return pObj->fTerm && pObj->iDiff0 != GIA_NONE; } 

static int Gia_ObjIsConst ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 915 of file gia.h.

{ return Gia_ObjRepr(p, Id) == 0;                                   }

static int Gia_ObjIsConst0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 430 of file gia.h.

{ return pObj->iDiff0 == GIA_NONE && pObj->iDiff1 == GIA_NONE;     } 

static int Gia_ObjIsFailedPair ( Gia_Man_t *  p, int  i, int  k  )

inlinestatic

Definition at line 921 of file gia.h.

{ assert( k ); return i? (Gia_ObjFailed(p, i) || Gia_ObjFailed(p, k)) : Gia_ObjFailed(p, k);                     }

static int Gia_ObjIsHead ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 916 of file gia.h.

{ return Gia_ObjRepr(p, Id) == GIA_VOID && Gia_ObjNext(p, Id) > 0;  }

static int Gia_ObjIsLut ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 952 of file gia.h.

{ return Vec_IntEntry(p->vMapping, Id) != 0;                                    }

static int Gia_ObjIsMux ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 425 of file gia.h.

{ return Gia_ObjIsMuxId( p, Gia_ObjId(p, pObj) ); } 

static int Gia_ObjIsMuxId ( Gia_Man_t *  p, int  iObj  )

inlinestatic

Definition at line 424 of file gia.h.

{ return p->pMuxes && p->pMuxes[iObj] > 0;        } 

int Gia_ObjIsMuxType

(

Gia_Obj_t *

pNode

)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 885 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)));
}

static int Gia_ObjIsNone ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 917 of file gia.h.

{ return Gia_ObjRepr(p, Id) == GIA_VOID && Gia_ObjNext(p, Id) == 0; }

static int Gia_ObjIsPi ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 441 of file gia.h.

{ return Gia_ObjIsCi(pObj) && Gia_ObjCioId(pObj) < Gia_ManPiNum(p);   } 

static int Gia_ObjIsPo ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 442 of file gia.h.

{ return Gia_ObjIsCo(pObj) && Gia_ObjCioId(pObj) < Gia_ManPoNum(p);   } 

static int Gia_ObjIsRi ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 444 of file gia.h.

{ return Gia_ObjIsCo(pObj) && Gia_ObjCioId(pObj) >= Gia_ManPoNum(p);  } 

static int Gia_ObjIsRo ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 443 of file gia.h.

{ return Gia_ObjIsCi(pObj) && Gia_ObjCioId(pObj) >= Gia_ManPiNum(p);  } 

static int Gia_ObjIsTail ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 918 of file gia.h.

{ return (Gia_ObjRepr(p, Id) > 0 && Gia_ObjRepr(p, Id) != GIA_VOID) && Gia_ObjNext(p, Id) == 0;                  }

static int Gia_ObjIsTerm ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 418 of file gia.h.

{ return pObj->fTerm;                             } 

static int Gia_ObjIsTravIdCurrent ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 533 of file gia.h.

{ assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); return (p->pTravIds[Gia_ObjId(p, pObj)] == p->nTravIds);          }

static int Gia_ObjIsTravIdCurrentId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 536 of file gia.h.

{ assert( Id < p->nTravIdsAlloc ); return (p->pTravIds[Id] == p->nTravIds);           }

static int Gia_ObjIsTravIdPrevious ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 534 of file gia.h.

{ assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); return (p->pTravIds[Gia_ObjId(p, pObj)] == p->nTravIds - 1);      }

static int Gia_ObjIsXor ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 423 of file gia.h.

{ return Gia_ObjIsAnd(pObj) && pObj->iDiff0 < pObj->iDiff1; } 

static int Gia_ObjLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 501 of file gia.h.

{ return Gia_ObjLevelId( p, Gia_ObjId(p,pObj) );             }

static int Gia_ObjLevelId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 500 of file gia.h.

{ return Vec_IntGetEntry(p->vLevels, Id);                    }

static int Gia_ObjLitCopy ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 479 of file gia.h.

{ return Abc_LitNotCond( Gia_ManObj(p, Abc_Lit2Var(iLit))->Value, Abc_LitIsCompl(iLit));     }

static int Gia_ObjLutFanin ( Gia_Man_t *  p, int  Id, int  i  )

inlinestatic

Definition at line 955 of file gia.h.

{ return Gia_ObjLutFanins(p, Id)[i];                                            }

static int* Gia_ObjLutFanins ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 954 of file gia.h.

{ return Vec_IntEntryP(p->vMapping, Vec_IntEntry(p->vMapping, Id)) + 1;         }

static int Gia_ObjLutIsMux ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 957 of file gia.h.

{ return (int)(Gia_ObjLutMuxId(p, Id) < 0);                                     }

static int Gia_ObjLutMuxId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 956 of file gia.h.

{ return Gia_ObjLutFanins(p, Id)[Gia_ObjLutSize(p, Id)];                        }

static int Gia_ObjLutSize ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 953 of file gia.h.

{ return Vec_IntEntry(p->vMapping, Vec_IntEntry(p->vMapping, Id));              }

static int Gia_ObjNext ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 912 of file gia.h.

{ return p->pNexts[Id];                                             }

static Gia_Obj_t* Gia_ObjNextObj ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 911 of file gia.h.

{ return p->pNexts[Id] == 0 ? NULL : Gia_ManObj( p, p->pNexts[Id] );}

static int Gia_ObjNum ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 513 of file gia.h.

{ return Vec_IntEntry(p->vTtNums, Gia_ObjId(p,pObj));      }

static int Gia_ObjNumId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 512 of file gia.h.

{ return Vec_IntEntry(p->vTtNums, Id);                     }

static int Gia_ObjPhase ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 415 of file gia.h.

{ return pObj->fPhase;                                        }

static int Gia_ObjPhaseReal ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 416 of file gia.h.

{ return Gia_Regular(pObj)->fPhase ^ Gia_IsComplement(pObj);  }

static int Gia_ObjPhaseRealLit ( Gia_Man_t *  p, int  iLit  )

inlinestatic

Definition at line 498 of file gia.h.

{ return Gia_ObjPhaseReal( Gia_ObjFromLit(p, iLit) );                            }

void Gia_ObjPrint	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj
	)

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

Synopsis [Verbose printing of the AIG node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1258 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" );
    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;
    }
*/
}

static int Gia_ObjProved ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 896 of file gia.h.

{ return p->pReprs[Id].fProved;       }

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

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 921 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;
    *ppFan0 = Gia_ObjChild0(p0);
    *ppFan1 = Gia_ObjChild1(p0);
    return 1;
}

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

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

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

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

SideEffects []

SeeAlso []

Definition at line 959 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;
}

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

Definition at line 1036 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 );
}

static int Gia_ObjRefDec ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 523 of file gia.h.

{ return Gia_ObjRefDecId( p, Gia_ObjId(p, pObj) );  }

static int Gia_ObjRefDecId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 520 of file gia.h.

{ return --p->pRefs[Id];                            }

static void Gia_ObjRefFanin0Dec ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 527 of file gia.h.

{ Gia_ObjRefDec(p, Gia_ObjFanin0(pObj));            }

static void Gia_ObjRefFanin0Inc ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 524 of file gia.h.

{ Gia_ObjRefInc(p, Gia_ObjFanin0(pObj));            }

static void Gia_ObjRefFanin1Dec ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 528 of file gia.h.

{ Gia_ObjRefDec(p, Gia_ObjFanin1(pObj));            }

static void Gia_ObjRefFanin1Inc ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 525 of file gia.h.

{ Gia_ObjRefInc(p, Gia_ObjFanin1(pObj));            }

static void Gia_ObjRefFanin2Dec ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 529 of file gia.h.

{ Gia_ObjRefDec(p, Gia_ObjFanin2(p, pObj));         }

static void Gia_ObjRefFanin2Inc ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 526 of file gia.h.

{ Gia_ObjRefInc(p, Gia_ObjFanin2(p, pObj));         }

static int Gia_ObjRefInc ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 522 of file gia.h.

{ return Gia_ObjRefIncId( p, Gia_ObjId(p, pObj) );  }

static int Gia_ObjRefIncId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 519 of file gia.h.

{ return p->pRefs[Id]++;                            }

static int Gia_ObjRefNum ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 521 of file gia.h.

{ return Gia_ObjRefNumId( p, Gia_ObjId(p, pObj) );  }

static int Gia_ObjRefNumId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 518 of file gia.h.

{ return p->pRefs[Id];                              }

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

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(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;
}

static int Gia_ObjRepr ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 887 of file gia.h.

{ return p->pReprs[Id].iRepr;                                                }

static Gia_Obj_t* Gia_ObjReprObj ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 886 of file gia.h.

{ return p->pReprs[Id].iRepr == GIA_VOID ? NULL : Gia_ManObj( p, p->pReprs[Id].iRepr );                  }

static int Gia_ObjReprSelf ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 892 of file gia.h.

{ return Gia_ObjHasRepr(p, Id) ? Gia_ObjRepr(p, Id) : Id;                    }

static void Gia_ObjResetNumId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 516 of file gia.h.

{ Vec_IntWriteEntry(p->vTtNums, Id, -ABC_INFINITY);        }

static Gia_Obj_t* Gia_ObjRiToRo ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 447 of file gia.h.

{ assert( Gia_ObjIsRi(p, pObj) ); return Gia_ManCi(p, Gia_ManCiNum(p) - Gia_ManCoNum(p) + Gia_ObjCioId(pObj)); } 

static Gia_Obj_t* Gia_ObjRoToRi ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 446 of file gia.h.

{ assert( Gia_ObjIsRo(p, pObj) ); return Gia_ManCo(p, Gia_ManCoNum(p) - Gia_ManCiNum(p) + Gia_ObjCioId(pObj)); } 

static void Gia_ObjSetAndLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 506 of file gia.h.

{ assert( Gia_ObjIsAnd(pObj) ); Gia_ObjSetLevel( p, pObj, 1+Abc_MaxInt(Gia_ObjLevel(p,Gia_ObjFanin0(pObj)),Gia_ObjLevel(p,Gia_ObjFanin1(pObj))) ); }

static void Gia_ObjSetBufLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 505 of file gia.h.

{ assert( Gia_ObjIsAnd(pObj) ); Gia_ObjSetLevel( p, pObj, Gia_ObjLevel(p,Gia_ObjFanin0(pObj)) );                                                }

static void Gia_ObjSetCioId ( Gia_Obj_t *  pObj, int  v  )

inlinestatic

Definition at line 412 of file gia.h.

{ assert( pObj->fTerm ); pObj->iDiff1 = v;                    }

static void Gia_ObjSetCoLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 504 of file gia.h.

{ assert( Gia_ObjIsCo(pObj)  ); Gia_ObjSetLevel( p, pObj, Gia_ObjLevel(p,Gia_ObjFanin0(pObj)) );                                                }

static void Gia_ObjSetColor ( Gia_Man_t *  p, int  Id, int  c  )

inlinestatic

Definition at line 905 of file gia.h.

{ if (c) p->pReprs[Id].fColorB = 1; else p->pReprs[Id].fColorA = 1; }

static void Gia_ObjSetColors ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 906 of file gia.h.

{ p->pReprs[Id].fColorB = p->pReprs[Id].fColorA = 1;                }

static void Gia_ObjSetCopyArray ( Gia_Man_t *  p, int  iObj, int  iLit  )

inlinestatic

Definition at line 488 of file gia.h.

{ Vec_IntWriteEntry(&p->vCopies, iObj, iLit);                                      }

static void Gia_ObjSetCopyF ( Gia_Man_t *  p, int  f, Gia_Obj_t *  pObj, int  iLit  )

inlinestatic

Definition at line 486 of file gia.h.

{ Vec_IntWriteEntry(&p->vCopies, Gia_ManObjNum(p) * f + Gia_ObjId(p,pObj), iLit);  }

static void Gia_ObjSetFailed ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 901 of file gia.h.

{ p->pReprs[Id].fFailed = 1;          }

static void Gia_ObjSetFanout ( Gia_Man_t *  p, Gia_Obj_t *  pObj, int  i, Gia_Obj_t *  pFan  )

inlinestatic

Definition at line 944 of file gia.h.

{ Vec_IntWriteEntry( p->vFanout, Gia_ObjFoffset(p, pObj) + i, Gia_ObjId(p, pFan) ); }

static void Gia_ObjSetGateLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 509 of file gia.h.

{ if ( Gia_ObjIsBuf(pObj) ) Gia_ObjSetBufLevel(p, pObj); else if ( Gia_ObjIsMux(p,pObj) ) Gia_ObjSetMuxLevel(p, pObj); else if ( Gia_ObjIsXor(pObj) ) Gia_ObjSetXorLevel(p, pObj); else if ( Gia_ObjIsAnd(pObj) ) Gia_ObjSetAndLevel(p, pObj); }

static void Gia_ObjSetLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj, int  l  )

inlinestatic

Definition at line 503 of file gia.h.

{ Gia_ObjSetLevelId( p, Gia_ObjId(p,pObj), l );       }

static void Gia_ObjSetLevelId ( Gia_Man_t *  p, int  Id, int  l  )

inlinestatic

Definition at line 502 of file gia.h.

{ Vec_IntSetEntry(p->vLevels, Id, l);                        }

static void Gia_ObjSetMuxLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 508 of file gia.h.

{ assert( Gia_ObjIsMux(p,pObj) ); Gia_ObjSetLevel( p, pObj, 2+Abc_MaxInt( Abc_MaxInt(Gia_ObjLevel(p,Gia_ObjFanin0(pObj)),Gia_ObjLevel(p,Gia_ObjFanin1(pObj))), Gia_ObjLevel(p,Gia_ObjFanin2(p,pObj))) ); }

static void Gia_ObjSetNext ( Gia_Man_t *  p, int  Id, int  Num  )

inlinestatic

Definition at line 913 of file gia.h.

{ p->pNexts[Id] = Num;                                              }

static void Gia_ObjSetNum ( Gia_Man_t *  p, Gia_Obj_t *  pObj, int  n  )

inlinestatic

Definition at line 515 of file gia.h.

{ Vec_IntWriteEntry(p->vTtNums, Gia_ObjId(p,pObj), n);     }

static void Gia_ObjSetNumId ( Gia_Man_t *  p, int  Id, int  n  )

inlinestatic

Definition at line 514 of file gia.h.

{ Vec_IntWriteEntry(p->vTtNums, Id, n);                    }

void Gia_ObjSetPhase	(	Gia_Man_t *	p,
		Gia_Obj_t *	pObj
	)

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

Synopsis [Sets the phase of one object.]

Description []

SideEffects []

SeeAlso []

Definition at line 346 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;
}

static void Gia_ObjSetProved ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 897 of file gia.h.

{ p->pReprs[Id].fProved = 1;          }

static void Gia_ObjSetRepr ( Gia_Man_t *  p, int  Id, int  Num  )

inlinestatic

Definition at line 888 of file gia.h.

{ assert( Num == GIA_VOID || Num < Id ); p->pReprs[Id].iRepr = Num;          }

static void Gia_ObjSetReprRev ( Gia_Man_t *  p, int  Id, int  Num  )

inlinestatic

Definition at line 889 of file gia.h.

{ assert( Num == GIA_VOID || Num > Id ); p->pReprs[Id].iRepr = Num;          }

static void Gia_ObjSetTimeArrival ( Gia_Man_t *  p, int  Id, float  t  )

inlinestatic

Definition at line 547 of file gia.h.

{ Vec_FltWriteEntry( p->vTiming, 3*Id+0, t );                                         }

static void Gia_ObjSetTimeArrivalObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj, float  t  )

inlinestatic

Definition at line 550 of file gia.h.

{ Gia_ObjSetTimeArrival( p, Gia_ObjId(p, pObj), t );                               }

static void Gia_ObjSetTimeRequired ( Gia_Man_t *  p, int  Id, float  t  )

inlinestatic

Definition at line 548 of file gia.h.

{ Vec_FltWriteEntry( p->vTiming, 3*Id+1, t );                                         }

static void Gia_ObjSetTimeRequiredObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj, float  t  )

inlinestatic

Definition at line 551 of file gia.h.

{ Gia_ObjSetTimeRequired( p, Gia_ObjId(p, pObj), t );                              }

static void Gia_ObjSetTimeSlack ( Gia_Man_t *  p, int  Id, float  t  )

inlinestatic

Definition at line 549 of file gia.h.

{ Vec_FltWriteEntry( p->vTiming, 3*Id+2, t );                                         }

static void Gia_ObjSetTimeSlackObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj, float  t  )

inlinestatic

Definition at line 552 of file gia.h.

{ Gia_ObjSetTimeSlack( p, Gia_ObjId(p, pObj), t );                                 }

static void Gia_ObjSetTravIdCurrent ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 531 of file gia.h.

{ assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); p->pTravIds[Gia_ObjId(p, pObj)] = p->nTravIds;                    }

static void Gia_ObjSetTravIdCurrentId ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 535 of file gia.h.

{ assert( Id < p->nTravIdsAlloc ); p->pTravIds[Id] = p->nTravIds;                     }

static void Gia_ObjSetTravIdPrevious ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 532 of file gia.h.

{ assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); p->pTravIds[Gia_ObjId(p, pObj)] = p->nTravIds - 1;                }

static void Gia_ObjSetValue ( Gia_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 414 of file gia.h.

{ pObj->Value = i;                                            }

static void Gia_ObjSetXorLevel ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 507 of file gia.h.

{ assert( Gia_ObjIsXor(pObj) ); Gia_ObjSetLevel( p, pObj, 2+Abc_MaxInt(Gia_ObjLevel(p,Gia_ObjFanin0(pObj)),Gia_ObjLevel(p,Gia_ObjFanin1(pObj))) ); }

static int Gia_ObjSibl ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 893 of file gia.h.

{ return p->pSibls ? p->pSibls[Id] : 0;                                      }

static Gia_Obj_t* Gia_ObjSiblObj ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 894 of file gia.h.

{ return (p->pSibls && p->pSibls[Id]) ? Gia_ManObj(p, p->pSibls[Id]) : NULL; }

static word* Gia_ObjSim ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 556 of file gia.h.

{ return Vec_WrdEntryP( p->vSims, Id * Gia_ObjSimWords(p) );     }

static word* Gia_ObjSimObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 557 of file gia.h.

{ return Gia_ObjSim( p, Gia_ObjId(p, pObj) );                    }

static word* Gia_ObjSimPi ( Gia_Man_t *  p, int  PiId  )

inlinestatic

Definition at line 555 of file gia.h.

{ return Vec_WrdEntryP( p->vSimsPi, PiId * Gia_ObjSimWords(p) ); }

static int Gia_ObjSimWords ( Gia_Man_t *  p )

inlinestatic

Definition at line 554 of file gia.h.

{ return Vec_WrdSize( p->vSimsPi ) / Gia_ManPiNum( p );          }

static void Gia_ObjTerSimAnd ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 785 of file gia.h.

{
    assert( Gia_ObjIsAnd(pObj) );
    assert( !Gia_ObjTerSimGetC( Gia_ObjFanin0(pObj) ) );
    assert( !Gia_ObjTerSimGetC( Gia_ObjFanin1(pObj) ) );
    if ( Gia_ObjTerSimGet0Fanin0(pObj) || Gia_ObjTerSimGet0Fanin1(pObj) )
        Gia_ObjTerSimSet0( pObj );
    else if ( Gia_ObjTerSimGet1Fanin0(pObj) && Gia_ObjTerSimGet1Fanin1(pObj) )
        Gia_ObjTerSimSet1( pObj );
    else 
        Gia_ObjTerSimSetX( pObj );
}

static void Gia_ObjTerSimCo ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 797 of file gia.h.

{
    assert( Gia_ObjIsCo(pObj) );
    assert( !Gia_ObjTerSimGetC( Gia_ObjFanin0(pObj) ) );
    if ( Gia_ObjTerSimGet0Fanin0(pObj) )
        Gia_ObjTerSimSet0( pObj );
    else if ( Gia_ObjTerSimGet1Fanin0(pObj) )
        Gia_ObjTerSimSet1( pObj );
    else 
        Gia_ObjTerSimSetX( pObj );
}

static int Gia_ObjTerSimGet0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 775 of file gia.h.

{ return  pObj->fMark0 && !pObj->fMark1; }

static int Gia_ObjTerSimGet0Fanin0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 779 of file gia.h.

{ return (Gia_ObjTerSimGet1(Gia_ObjFanin0(pObj)) && Gia_ObjFaninC0(pObj)) || (Gia_ObjTerSimGet0(Gia_ObjFanin0(pObj)) && !Gia_ObjFaninC0(pObj)); }

static int Gia_ObjTerSimGet0Fanin1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 782 of file gia.h.

{ return (Gia_ObjTerSimGet1(Gia_ObjFanin1(pObj)) && Gia_ObjFaninC1(pObj)) || (Gia_ObjTerSimGet0(Gia_ObjFanin1(pObj)) && !Gia_ObjFaninC1(pObj)); }

static int Gia_ObjTerSimGet1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 776 of file gia.h.

{ return !pObj->fMark0 &&  pObj->fMark1; }

static int Gia_ObjTerSimGet1Fanin0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 780 of file gia.h.

{ return (Gia_ObjTerSimGet0(Gia_ObjFanin0(pObj)) && Gia_ObjFaninC0(pObj)) || (Gia_ObjTerSimGet1(Gia_ObjFanin0(pObj)) && !Gia_ObjFaninC0(pObj)); }

static int Gia_ObjTerSimGet1Fanin1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 783 of file gia.h.

{ return (Gia_ObjTerSimGet0(Gia_ObjFanin1(pObj)) && Gia_ObjFaninC1(pObj)) || (Gia_ObjTerSimGet1(Gia_ObjFanin1(pObj)) && !Gia_ObjFaninC1(pObj)); }

static int Gia_ObjTerSimGetC ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 774 of file gia.h.

{ return !pObj->fMark0 && !pObj->fMark1; }

static int Gia_ObjTerSimGetX ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 777 of file gia.h.

{ return  pObj->fMark0 &&  pObj->fMark1; }

static void Gia_ObjTerSimPrint ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 817 of file gia.h.

{
    if ( Gia_ObjTerSimGet0(pObj) )
        printf( "0" );
    else if ( Gia_ObjTerSimGet1(pObj) )
        printf( "1" );
    else if ( Gia_ObjTerSimGetX(pObj) )
        printf( "X" );
}

static void Gia_ObjTerSimRo ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 808 of file gia.h.

{
    Gia_Obj_t * pTemp = Gia_ObjRoToRi(p, pObj);
    assert( Gia_ObjIsRo(p, pObj) );
    assert( !Gia_ObjTerSimGetC( pTemp ) );
    pObj->fMark0 = pTemp->fMark0;
    pObj->fMark1 = pTemp->fMark1;
}

static void Gia_ObjTerSimSet0 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 770 of file gia.h.

{ pObj->fMark0 = 1; pObj->fMark1 = 0;    }

static void Gia_ObjTerSimSet1 ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 771 of file gia.h.

{ pObj->fMark0 = 0; pObj->fMark1 = 1;    }

static void Gia_ObjTerSimSetC ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 769 of file gia.h.

{ pObj->fMark0 = 0; pObj->fMark1 = 0;    }

static void Gia_ObjTerSimSetX ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 772 of file gia.h.

{ pObj->fMark0 = 1; pObj->fMark1 = 1;    }

static float Gia_ObjTimeArrival ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 541 of file gia.h.

{ return Vec_FltEntry(p->vTiming, 3*Id+0);                                            }

static float Gia_ObjTimeArrivalObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 544 of file gia.h.

{ return Gia_ObjTimeArrival( p, Gia_ObjId(p, pObj) );                                 }

static float Gia_ObjTimeRequired ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 542 of file gia.h.

{ return Vec_FltEntry(p->vTiming, 3*Id+1);                                            }

static float Gia_ObjTimeRequiredObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 545 of file gia.h.

{ return Gia_ObjTimeRequired( p, Gia_ObjId(p, pObj) );                                }

static float Gia_ObjTimeSlack ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 543 of file gia.h.

{ return Vec_FltEntry(p->vTiming, 3*Id+2);                                            }

static float Gia_ObjTimeSlackObj ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 546 of file gia.h.

{ return Gia_ObjTimeSlack( p, Gia_ObjId(p, pObj) );                                   }

static int Gia_ObjToLit ( Gia_Man_t *  p, Gia_Obj_t *  pObj  )

inlinestatic

Definition at line 497 of file gia.h.

{ return Abc_Var2Lit( Gia_ObjId(p, Gia_Regular(pObj)), Gia_IsComplement(pObj) ); }

static void Gia_ObjUnsetProved ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 898 of file gia.h.

{ p->pReprs[Id].fProved = 0;          }

static void Gia_ObjUnsetRepr ( Gia_Man_t *  p, int  Id  )

inlinestatic

Definition at line 890 of file gia.h.

{ p->pReprs[Id].iRepr = GIA_VOID;                                            }

static int Gia_ObjValue ( Gia_Obj_t *  pObj )

inlinestatic

Definition at line 413 of file gia.h.

{ return pObj->Value;                                         }

static int Gia_ObjVisitColor ( Gia_Man_t *  p, int  Id, int  c  )

inlinestatic

Definition at line 907 of file gia.h.

{ int x; if (c) { x = p->pReprs[Id].fColorB; p->pReprs[Id].fColorB = 1; } else { x = p->pReprs[Id].fColorA; p->pReprs[Id].fColorA = 1; } return x; }

static int Gia_ObjWhatFanin ( Gia_Obj_t *  pObj, Gia_Obj_t *  pFanin  )

inlinestatic

Definition at line 473 of file gia.h.

{ return Gia_ObjFanin0(pObj) == pFanin ? 0 : (Gia_ObjFanin1(pObj) == pFanin ? 1 : -1); }

static Gia_Obj_t* Gia_Regular ( Gia_Obj_t *  p )

inlinestatic

Definition at line 377 of file gia.h.

{ return (Gia_Obj_t *)((ABC_PTRUINT_T)(p) & ~01);                           }

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

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

unsigned* Gia_SimDataCiExt	(	Gia_ManSim_t *	p,
		int	i
	)

Definition at line 35 of file giaSim.c.

{ return Gia_SimDataCi(p, i);  }

unsigned* Gia_SimDataCoExt	(	Gia_ManSim_t *	p,
		int	i
	)

Definition at line 36 of file giaSim.c.

{ return Gia_SimDataCo(p, i);  }

unsigned* Gia_SimDataExt	(	Gia_ManSim_t *	p,
		int	i
	)

Definition at line 34 of file giaSim.c.

{ return Gia_SimData(p, i);    }

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

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

int Gia_SweeperCheckEquiv	(	Gia_Man_t *	pGia,
		int	Probe1,
		int	Probe2
	)

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

Gia_Man_t* Gia_SweeperCleanup	(	Gia_Man_t *	p,
		char *	pCommLime
	)

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

Vec_Int_t* Gia_SweeperCollectValidProbeIds

(

Gia_Man_t *

p

)

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

int Gia_SweeperCondCheckUnsat

(

Gia_Man_t *

pGia

)

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

int Gia_SweeperCondPop

(

Gia_Man_t *

p

)

Definition at line 324 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    return Vec_IntPop( pSwp->vCondProbes );
}

void Gia_SweeperCondPush	(	Gia_Man_t *	p,
		int	ProbeId
	)

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

Vec_Int_t* Gia_SweeperCondVector

(

Gia_Man_t *

p

)

Definition at line 329 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    return pSwp->vCondProbes;
}

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

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

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

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

Vec_Int_t* Gia_SweeperGetCex

(

Gia_Man_t *

p

)

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

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

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

int Gia_SweeperIsRunning

(

Gia_Man_t *

p

)

Definition at line 164 of file giaSweeper.c.

{
    return (pGia->pData != NULL);
}

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

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 );
    Gia_ManStop( pGiaOuts );
    printf( " into file \"%s\".\n", pFileName );
}

void Gia_SweeperPrintStats

(

Gia_Man_t *

p

)

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

int Gia_SweeperProbeCreate	(	Gia_Man_t *	p,
		int	iLit
	)

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

int Gia_SweeperProbeDelete	(	Gia_Man_t *	p,
		int	ProbeId
	)

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

int Gia_SweeperProbeLit	(	Gia_Man_t *	p,
		int	ProbeId
	)

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

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

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

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

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

void Gia_SweeperSetConflictLimit	(	Gia_Man_t *	p,
		int	nConfMax
	)

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

void Gia_SweeperSetRuntimeLimit	(	Gia_Man_t *	p,
		int	nSeconds
	)

Definition at line 225 of file giaSweeper.c.

{
    Swp_Man_t * pSwp = (Swp_Man_t *)p->pData;
    pSwp->nTimeOut = nSeconds;
}

Gia_Man_t* Gia_SweeperStart

(

Gia_Man_t *

p

)

Definition at line 145 of file giaSweeper.c.

{
    if ( pGia == NULL )
        pGia = Gia_ManStart( 10000 );
    if ( pGia->pHTable == NULL )
        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;
}

void Gia_SweeperStop

(

Gia_Man_t *

p

)

Definition at line 157 of file giaSweeper.c.

{
    pGia->fSweeper = 0;
    Swp_ManStop( pGia );
    Gia_ManHashStop( pGia );
//    Gia_ManStop( pGia );
}

char* Gia_TimeStamp

(

)

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

Synopsis [Returns the time stamp.]

Description [The file should be closed.]

SideEffects []

SeeAlso []

Definition at line 101 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;
}

static int Gia_WordCountOnes ( unsigned  uWord )

inlinestatic

Definition at line 313 of file gia.h.

{
    uWord = (uWord & 0x55555555) + ((uWord>>1) & 0x55555555);
    uWord = (uWord & 0x33333333) + ((uWord>>2) & 0x33333333);
    uWord = (uWord & 0x0F0F0F0F) + ((uWord>>4) & 0x0F0F0F0F);
    uWord = (uWord & 0x00FF00FF) + ((uWord>>8) & 0x00FF00FF);
    return  (uWord & 0x0000FFFF) + (uWord>>16);
}

static int Gia_WordFindFirstBit ( unsigned  uWord )

inlinestatic

Definition at line 321 of file gia.h.

{
    int i;
    for ( i = 0; i < 32; i++ )
        if ( uWord & (1 << i) )
            return i;
    return -1;
}

static int Gia_WordHasOneBit ( unsigned  uWord )

inlinestatic

Definition at line 311 of file gia.h.

{ return (uWord & (uWord-1)) == 0;                            }

static int Gia_WordHasOnePair ( unsigned  uWord )

inlinestatic

Definition at line 312 of file gia.h.

{ return Gia_WordHasOneBit(uWord & (uWord>>1) & 0x55555555);  }

static int Gia_XsimAndCond ( int  Value0, int  fCompl0, int  Value1, int  fCompl1  )

inlinestatic

Definition at line 759 of file gia.h.

{ 
    if ( Value0 == GIA_ZER + fCompl0 || Value1 == GIA_ZER + fCompl1 )
        return GIA_ZER;
    if ( Value0 == GIA_UND || Value1 == GIA_UND )
        return GIA_UND;
    return GIA_ONE;
}

static int Gia_XsimNotCond ( int  Value, int  fCompl  )

inlinestatic

Definition at line 751 of file gia.h.

{ 
    if ( Value == GIA_UND )
        return GIA_UND;
    if ( Value == GIA_ZER + fCompl )
        return GIA_ZER;
    return GIA_ONE;
}

Gia_Man_t* Jf_ManDeriveCnf	(	Gia_Man_t *	p,
		int	fCnfObjIds
	)

Definition at line 1746 of file giaJf.c.

{
    Jf_Par_t Pars, * pPars = &Pars;
    Jf_ManSetDefaultPars( pPars );
    pPars->fGenCnf = 1;
    pPars->fCnfObjIds = fCnfObjIds;
    return Jf_ManPerformMapping( p, pPars );
}

Gia_Man_t* Jf_ManPerformMapping	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars
	)

Definition at line 1712 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;
}

void Jf_ManSetDefaultPars

(

Jf_Par_t *

pPars

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1679 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;
}

Gia_Man_t* Lf_ManPerformMapping	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars
	)

Definition at line 2193 of file giaLf.c.

{
    Gia_Man_t * pNew;
    if ( p->pManTime && Tim_ManBoxNum(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 );
        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;
}

void Lf_ManSetDefaultPars

(

Jf_Par_t *

pPars

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1981 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;
}

Gia_Man_t* Mf_ManPerformMapping	(	Gia_Man_t *	pGia,
		Jf_Par_t *	pPars
	)

Definition at line 1575 of file giaMf.c.

{
    Mf_Man_t * p;
    Gia_Man_t * pNew, * pCls;
    if ( pPars->fGenCnf )
        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 );
    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 )
//        Mf_ManProfileTruths( p );
    Gia_ManMappingVerify( pNew );
    Mf_ManPrintQuit( p, pNew );
    Mf_ManFree( p );
    if ( pCls != pGia )
        Gia_ManStop( pCls );
    return pNew;
}

void Mf_ManSetDefaultPars

(

Jf_Par_t *

pPars

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1380 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->fPureAig     =  0;
    pPars->fVerbose     =  0;
    pPars->fVeryVerbose =  0;
    pPars->nLutSizeMax  =  MF_LEAF_MAX;
    pPars->nCutNumMax   =  MF_CUT_MAX;
}

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

Tas_Man_t* Tas_ManAlloc	(	Gia_Man_t *	pAig,
		int	nBTLimit
	)

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

void Tas_ManSatPrintStats

(

Tas_Man_t *

p

)

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

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

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

int Tas_ManSolveArray	(	Tas_Man_t *	p,
		Vec_Ptr_t *	vObjs
	)

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

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

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

void Tas_ManStop

(

Tas_Man_t *

p

)

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

Vec_Int_t* Tas_ReadModel

(

Tas_Man_t *

p

)

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

Synopsis [Returns satisfying assignment.]

Description []

SideEffects []

SeeAlso []

Definition at line 250 of file giaCTas.c.

{
    return p->vModel;
}