ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [Creates AIG.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Gia_Man_t * Gia_ManStart( int nObjsMax ) { 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; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Abc_IffMan_t * Abc_NtkIfifStart( Abc_Ntk_t * pNtk, Ifif_Par_t * pPars ) { Abc_IffMan_t * p; p = ABC_CALLOC( Abc_IffMan_t, 1 ); p->pNtk = pNtk; p->pPars = pPars; // internal data p->nObjs = Abc_NtkObjNumMax( pNtk ); p->pObjs = ABC_CALLOC( Abc_IffObj_t, p->nObjs ); return p; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Agi_Man_t * Agi_ManAlloc( int nCap ) { Agi_Man_t * p; nCap = Abc_MaxInt( nCap, 16 ); p = ABC_CALLOC( Agi_Man_t, 1 ); p->nCap = nCap; p->pObjs = ABC_CALLOC( word, nCap ); p->pTravIds = ABC_CALLOC( unsigned, nCap ); p->pObjs[0] = AGI_C0; p->nObjs = 1; return p; }
/**Function************************************************************* Synopsis [Creating/deleting the manager.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline Swp_Man_t * Swp_ManStart( Gia_Man_t * pGia ) { Swp_Man_t * p; int Lit; assert( pGia->pHTable != NULL ); pGia->pData = p = ABC_CALLOC( Swp_Man_t, 1 ); p->pGia = pGia; p->nConfMax = 1000; p->vProbes = Vec_IntAlloc( 100 ); p->vProbRefs = Vec_IntAlloc( 100 ); p->vLit2Prob = Vec_IntStartFull( 10000 ); p->vCondProbes = Vec_IntAlloc( 100 ); p->vCondAssump = Vec_IntAlloc( 100 ); p->vId2Lit = Vec_IntAlloc( 10000 ); p->vFront = Vec_IntAlloc( 100 ); p->vFanins = Vec_IntAlloc( 100 ); p->vCexSwp = Vec_IntAlloc( 100 ); p->pSat = sat_solver_new(); p->nSatVars = 1; sat_solver_setnvars( p->pSat, 1000 ); Swp_ManSetObj2Lit( p, 0, (Lit = Abc_Var2Lit(p->nSatVars++, 0)) ); Lit = Abc_LitNot(Lit); sat_solver_addclause( p->pSat, &Lit, &Lit + 1 ); p->timeStart = Abc_Clock(); return p; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Abc_Frame_t * Abc_FrameAllocate() { Abc_Frame_t * p; extern void define_cube_size( int n ); extern void set_espresso_flags(); // allocate and clean p = ABC_CALLOC( Abc_Frame_t, 1 ); // get version p->sVersion = Abc_UtilsGetVersion( p ); // set streams p->Err = stderr; p->Out = stdout; p->Hst = NULL; p->Status = -1; p->nFrames = -1; // set the starting step p->nSteps = 1; p->fBatchMode = 0; // networks to be used by choice p->vStore = Vec_PtrAlloc( 16 ); // initialize decomposition manager // define_cube_size(20); // set_espresso_flags(); // initialize the trace manager // Abc_HManStart(); return p; }
/**Function************************************************************* Synopsis [Creates fast simulation manager.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Saig_SimObj_t * Saig_ManCreateMan( Aig_Man_t * p ) { Saig_SimObj_t * pAig, * pEntry; Aig_Obj_t * pObj; int i; pAig = ABC_CALLOC( Saig_SimObj_t, Aig_ManObjNumMax(p)+1 ); // printf( "Allocating %7.2f Mb.\n", 1.0 * sizeof(Saig_SimObj_t) * (Aig_ManObjNumMax(p)+1)/(1<<20) ); Aig_ManForEachObj( p, pObj, i ) { pEntry = pAig + i; pEntry->Type = pObj->Type; if ( Aig_ObjIsPi(pObj) || i == 0 ) { if ( Saig_ObjIsLo(p, pObj) ) { pEntry->iFan0 = (Saig_ObjLoToLi(p, pObj)->Id << 1); pEntry->iFan1 = -1; } continue; } pEntry->iFan0 = (Aig_ObjFaninId0(pObj) << 1) | Aig_ObjFaninC0(pObj); if ( Aig_ObjIsPo(pObj) ) continue; assert( Aig_ObjIsNode(pObj) ); pEntry->iFan1 = (Aig_ObjFaninId1(pObj) << 1) | Aig_ObjFaninC1(pObj); }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Bus_Man_t * Bus_ManStart( Abc_Ntk_t * pNtk, SC_Lib * pLib, SC_BusPars * pPars ) { Bus_Man_t * p; p = ABC_CALLOC( Bus_Man_t, 1 ); p->pPars = pPars; p->pNtk = pNtk; p->pLib = pLib; p->pInv = Abc_SclFindInvertor(pLib, pPars->fAddBufs)->pRepr->pPrev;//->pAve; if ( pPars->fUseWireLoads ) { if ( pNtk->pWLoadUsed == NULL ) { p->pWLoadUsed = Abc_SclFindWireLoadModel( pLib, Abc_SclGetTotalArea(pNtk) ); pNtk->pWLoadUsed = Abc_UtilStrsav( p->pWLoadUsed->pName ); } else p->pWLoadUsed = Abc_SclFetchWireLoadModel( pLib, pNtk->pWLoadUsed ); } if ( p->pWLoadUsed ) p->vWireCaps = Abc_SclFindWireCaps( p->pWLoadUsed ); p->vFanouts = Vec_PtrAlloc( 100 ); p->vCins = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 ); p->vETimes = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 ); p->vLoads = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 ); p->vDepts = Vec_FltAlloc( 2*Abc_NtkObjNumMax(pNtk) + 1000 ); Vec_FltFill( p->vCins, Abc_NtkObjNumMax(pNtk), 0 ); Vec_FltFill( p->vETimes, Abc_NtkObjNumMax(pNtk), 0 ); Vec_FltFill( p->vLoads, Abc_NtkObjNumMax(pNtk), 0 ); Vec_FltFill( p->vDepts, Abc_NtkObjNumMax(pNtk), 0 ); pNtk->pBSMan = p; return p; }
ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Mig_Man_t * Mig_ManStart() { Mig_Man_t * p; assert( sizeof(Mig_Obj_t) >= 16 ); assert( (1 << MIG_BASE) == MIG_MASK + 1 ); p = ABC_CALLOC( Mig_Man_t, 1 ); Vec_IntGrow( &p->vCis, 1024 ); Vec_IntGrow( &p->vCos, 1024 ); Mig_ManAppendObj( p ); // const0 return p; }
/**Function************************************************************* Synopsis [Read equivalence classes from the string.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Gia_Rpr_t * Gia_ReadEquivClasses( unsigned char ** ppPos, int nSize ) { Gia_Rpr_t * pReprs; unsigned char * pStop; int i, Item, fProved, iRepr, iNode; pStop = *ppPos; pStop += Gia_ReadInt( *ppPos ); *ppPos += 4; pReprs = ABC_CALLOC( Gia_Rpr_t, nSize ); for ( i = 0; i < nSize; i++ ) pReprs[i].iRepr = GIA_VOID; iRepr = iNode = 0; while ( *ppPos < pStop ) { Item = Gia_ReadAigerDecode( ppPos ); if ( Item & 1 ) { iRepr += (Item >> 1); iNode = iRepr; //printf( "\nRepr = %d ", iRepr ); continue; } Item >>= 1; fProved = (Item & 1); Item >>= 1; iNode += Item; pReprs[iNode].fProved = fProved; pReprs[iNode].iRepr = iRepr; assert( iRepr < iNode ); //printf( "Node = %d ", iNode ); }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Gia_ManSat_t * Gia_ManSatStart() { Gia_ManSat_t * p; p = ABC_CALLOC( Gia_ManSat_t, 1 ); p->pMem = Aig_MmFlexStart(); return p; }
/**Function************************************************************* Synopsis [Working with models.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Wlc_Ntk_t * Wlc_NtkAlloc( char * pName, int nObjsAlloc ) { Wlc_Ntk_t * p; p = ABC_CALLOC( Wlc_Ntk_t, 1 ); p->pName = pName ? Extra_FileNameGeneric( pName ) : NULL; Vec_IntGrow( &p->vPis, 111 ); Vec_IntGrow( &p->vPos, 111 ); Vec_IntGrow( &p->vCis, 111 ); Vec_IntGrow( &p->vCos, 111 ); Vec_IntGrow( &p->vFfs, 111 ); p->pMemFanin = Mem_FlexStart(); p->nObjsAlloc = nObjsAlloc; p->pObjs = ABC_CALLOC( Wlc_Obj_t, p->nObjsAlloc ); p->iObj = 1; return p; }
Map_Time_t * Abc_NtkMapCopyCoRequiredCon( Abc_Ntk_t * pNtk ) { Map_Time_t * p; int i; p = ABC_CALLOC( Map_Time_t, Abc_NtkCoNum(pNtk) ); for ( i = 0; i < Abc_NtkCoNum(pNtk); i++ ) p[i].Fall = p[i].Rise = p[i].Worst = Scl_Int2Flt( Scl_ConGetOutReq(i) ); return p; }
/**Function************************************************************* Synopsis [Load the network into manager.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Map_Time_t * Abc_NtkMapCopyCiArrivalCon( Abc_Ntk_t * pNtk ) { Map_Time_t * p; int i; p = ABC_CALLOC( Map_Time_t, Abc_NtkCiNum(pNtk) ); for ( i = 0; i < Abc_NtkCiNum(pNtk); i++ ) p[i].Fall = p[i].Rise = p[i].Worst = Scl_Int2Flt( Scl_ConGetInArr(i) ); return p; }
/**Function************************************************************* Synopsis [Creates AIG.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Cec_ManPat_t * Cec_ManPatStart() { Cec_ManPat_t * p; p = ABC_CALLOC( Cec_ManPat_t, 1 ); p->vStorage = Vec_StrAlloc( 1<<20 ); p->vPattern1 = Vec_IntAlloc( 1000 ); p->vPattern2 = Vec_IntAlloc( 1000 ); return p; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Cbs0_Man_t * Cbs0_ManAlloc() { Cbs0_Man_t * p; p = ABC_CALLOC( Cbs0_Man_t, 1 ); p->pProp.nSize = p->pJust.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->vModel = Vec_IntAlloc( 1000 ); Cbs0_SetDefaultParams( &p->Pars ); return p; }
/**Function************************************************************* Synopsis [Creates logic network isomorphic to the given AIG.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Cof_Man_t * Cof_ManCreateLogicSimple( Gia_Man_t * pGia ) { Cof_Man_t * p; Cof_Obj_t * pObjLog, * pFanLog; Gia_Obj_t * pObj; int * pMuxRefs; int i, iHandle = 0; p = ABC_CALLOC( Cof_Man_t, 1 ); p->pGia = pGia; p->vCis = Vec_IntAlloc( Gia_ManCiNum(pGia) ); p->vCos = Vec_IntAlloc( Gia_ManCoNum(pGia) ); p->nObjData = (sizeof(Cof_Obj_t) / 4) * Gia_ManObjNum(pGia) + 4 * Gia_ManAndNum(pGia) + 2 * Gia_ManCoNum(pGia); p->pObjData = ABC_CALLOC( int, p->nObjData ); ABC_FREE( pGia->pRefs ); Gia_ManCreateRefs( pGia ); Gia_ManForEachObj( pGia, pObj, i ) { pObj->Value = iHandle; pObjLog = Cof_ManObj( p, iHandle ); pObjLog->nFanins = 0; pObjLog->nFanouts = Gia_ObjRefNum( pGia, pObj ); pObjLog->Id = i; pObjLog->Value = 0; if ( Gia_ObjIsAnd(pObj) ) { pFanLog = Cof_ManObj( p, Gia_ObjHandle(Gia_ObjFanin0(pObj)) ); pFanLog->Fanios[pFanLog->nFanins + pFanLog->Value++].iFan = pObjLog->Fanios[pObjLog->nFanins].iFan = Cof_ObjHandleDiff( pObjLog, pFanLog ); pObjLog->Fanios[pObjLog->nFanins++].fCompl = Gia_ObjFaninC0(pObj); pFanLog = Cof_ManObj( p, Gia_ObjHandle(Gia_ObjFanin1(pObj)) ); pFanLog->Fanios[pFanLog->nFanins + pFanLog->Value++].iFan = pObjLog->Fanios[pObjLog->nFanins].iFan = Cof_ObjHandleDiff( pObjLog, pFanLog ); pObjLog->Fanios[pObjLog->nFanins++].fCompl = Gia_ObjFaninC1(pObj); p->nNodes++; } else if ( Gia_ObjIsCo(pObj) ) { pFanLog = Cof_ManObj( p, Gia_ObjHandle(Gia_ObjFanin0(pObj)) ); pFanLog->Fanios[pFanLog->nFanins + pFanLog->Value++].iFan = pObjLog->Fanios[pObjLog->nFanins].iFan = Cof_ObjHandleDiff( pObjLog, pFanLog ); pObjLog->Fanios[pObjLog->nFanins++].fCompl = Gia_ObjFaninC0(pObj); pObjLog->fTerm = 1; Vec_IntPush( p->vCos, iHandle ); } else if ( Gia_ObjIsCi(pObj) ) { pObjLog->fTerm = 1; Vec_IntPush( p->vCis, iHandle ); } iHandle += Cof_ObjSize( pObjLog ); p->nObjs++; }
ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [Read/write equivalence classes information.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Gia_Rpr_t * Gia_AigerReadEquivClasses( unsigned char ** ppPos, int nSize ) { Gia_Rpr_t * pReprs; unsigned char * pStop; int i, Item, fProved, iRepr, iNode; pStop = *ppPos; pStop += Gia_AigerReadInt( *ppPos ); *ppPos += 4; pReprs = ABC_CALLOC( Gia_Rpr_t, nSize ); for ( i = 0; i < nSize; i++ ) pReprs[i].iRepr = GIA_VOID; iRepr = iNode = 0; while ( *ppPos < pStop ) { Item = Gia_AigerReadUnsigned( ppPos ); if ( Item & 1 ) { iRepr += (Item >> 1); iNode = iRepr; continue; } Item >>= 1; fProved = (Item & 1); Item >>= 1; iNode += Item; pReprs[iNode].fProved = fProved; pReprs[iNode].iRepr = iRepr; assert( iRepr < iNode ); }
Map_Time_t * Abc_NtkMapCopyCoRequired( Abc_Ntk_t * pNtk, Abc_Time_t * ppTimes ) { Map_Time_t * p; int i; p = ABC_CALLOC( Map_Time_t, Abc_NtkCoNum(pNtk) ); for ( i = 0; i < Abc_NtkCoNum(pNtk); i++ ) { p[i].Fall = ppTimes[i].Fall; p[i].Rise = ppTimes[i].Rise; p[i].Worst = Abc_MaxFloat( p[i].Fall, p[i].Rise ); } ABC_FREE( ppTimes ); return p; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Bal_Man_t * Bal_ManAlloc( Gia_Man_t * pGia, Gia_Man_t * pNew, int nLutSize, int nCutNum, int fVerbose ) { Bal_Man_t * p; p = ABC_CALLOC( Bal_Man_t, 1 ); p->clkStart = Abc_Clock(); p->pGia = pGia; p->pNew = pNew; p->nLutSize = nLutSize; p->nCutNum = nCutNum; p->fVerbose = fVerbose; p->vCosts = Vec_IntAlloc( 3 * Gia_ManObjNum(pGia) / 2 ); p->vCutSets = Vec_PtrAlloc( 3 * Gia_ManObjNum(pGia) / 2 ); Vec_IntFill( p->vCosts, Gia_ManObjNum(pNew), 0 ); Vec_PtrFill( p->vCutSets, Gia_ManObjNum(pNew), NULL ); pNew->pData = p; return p; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Bmc_Load_t * Bmc_LoadStart( Gia_Man_t * pGia ) { Bmc_Load_t * p; int Lit; Gia_ManSetPhase( pGia ); Gia_ManCleanValue( pGia ); Gia_ManCreateRefs( pGia ); p = ABC_CALLOC( Bmc_Load_t, 1 ); p->pGia = pGia; p->pSat = sat_solver_new(); p->vSat2Id = Vec_IntAlloc( 1000 ); Vec_IntPush( p->vSat2Id, 0 ); // create constant node Lit = Abc_Var2Lit( Bmc_LoadGetSatVar(p, 0), 1 ); sat_solver_addclause( p->pSat, &Lit, &Lit + 1 ); return p; }
Ssc_Man_t * Ssc_ManStart( Gia_Man_t * pAig, Gia_Man_t * pCare, Ssc_Pars_t * pPars ) { Ssc_Man_t * p; p = ABC_CALLOC( Ssc_Man_t, 1 ); p->pPars = pPars; p->pAig = pAig; p->pCare = pCare; p->pFraig = Gia_ManDupDfs( p->pCare ); assert( p->pFraig->pHTable == NULL ); assert( !Gia_ManHasDangling(p->pFraig) ); Gia_ManInvertPos( p->pFraig ); Ssc_ManStartSolver( p ); if ( p->pSat == NULL ) { printf( "Constraints are UNSAT after propagation (likely a bug!).\n" ); Ssc_ManStop( p ); return NULL; } // p->vPivot = Ssc_GiaFindPivotSim( p->pFraig ); // Vec_IntFreeP( &p->vPivot ); p->vPivot = Ssc_ManFindPivotSat( p ); if ( p->vPivot == NULL ) { printf( "Constraints are UNSAT or conflict limit is too low.\n" ); Ssc_ManStop( p ); return NULL; } sat_solver_bookmark( p->pSat ); // Vec_IntPrint( p->vPivot ); Gia_ManSetPhasePattern( p->pAig, p->vPivot ); Gia_ManSetPhasePattern( p->pCare, p->vPivot ); if ( Gia_ManCheckCoPhase(p->pCare) ) { printf( "Computed reference pattern violates %d constraints (this is a bug!).\n", Gia_ManCheckCoPhase(p->pCare) ); Ssc_ManStop( p ); return NULL; } // other things p->vDisPairs = Vec_IntAlloc( 100 ); p->vPattern = Vec_IntAlloc( 100 ); p->vFanins = Vec_IntAlloc( 100 ); p->vFront = Vec_IntAlloc( 100 ); Ssc_GiaClassesInit( pAig ); // now it is ready for refinement using simulation return p; }
void Abc_NtkTimeSetOutputLoad( Abc_Ntk_t * pNtk, int PoNum, float Rise, float Fall ) { Abc_Time_t * pTime; assert( PoNum >= 0 && PoNum < Abc_NtkCoNum(pNtk) ); if ( pNtk->pManTime == NULL ) pNtk->pManTime = Abc_ManTimeStart(); if ( pNtk->pManTime->tOutLoadDef.Rise == Rise && pNtk->pManTime->tOutLoadDef.Fall == Fall ) return; if ( pNtk->pManTime->tOutLoad == NULL ) { int i; pNtk->pManTime->tOutLoad = ABC_CALLOC( Abc_Time_t, Abc_NtkCoNum(pNtk) ); for ( i = 0; i < Abc_NtkCoNum(pNtk); i++ ) pNtk->pManTime->tOutLoad[i] = pNtk->pManTime->tOutLoadDef; } pTime = pNtk->pManTime->tOutLoad + PoNum; pTime->Rise = Rise; pTime->Fall = Fall; }
/**Function************************************************************* Synopsis [Sets the arrival time for an object.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NtkTimeSetInputDrive( Abc_Ntk_t * pNtk, int PiNum, float Rise, float Fall ) { Abc_Time_t * pTime; assert( PiNum >= 0 && PiNum < Abc_NtkCiNum(pNtk) ); if ( pNtk->pManTime == NULL ) pNtk->pManTime = Abc_ManTimeStart(); if ( pNtk->pManTime->tInDriveDef.Rise == Rise && pNtk->pManTime->tInDriveDef.Fall == Fall ) return; if ( pNtk->pManTime->tInDrive == NULL ) { int i; pNtk->pManTime->tInDrive = ABC_CALLOC( Abc_Time_t, Abc_NtkCiNum(pNtk) ); for ( i = 0; i < Abc_NtkCiNum(pNtk); i++ ) pNtk->pManTime->tInDrive[i] = pNtk->pManTime->tInDriveDef; } pTime = pNtk->pManTime->tInDrive + PiNum; pTime->Rise = Rise; pTime->Fall = Fall; }
Vec_Ptr_t * Wlc_NtkSimulate( Wlc_Ntk_t * p, Vec_Int_t * vNodes, int nWords, int nFrames ) { Gia_Obj_t * pObj; Vec_Ptr_t * vOne, * vRes; Gia_Man_t * pGia = Wlc_NtkBitBlast( p, NULL, 0, 0 ); Wlc_Obj_t * pWlcObj; int f, i, k, w, nBits, Counter = 0; // allocate simulation info for one timeframe Vec_WrdFreeP( &pGia->vSims ); pGia->vSims = Vec_WrdStart( Gia_ManObjNum(pGia) * nWords ); pGia->iPatsPi = nWords; // allocate resulting simulation info vRes = Vec_PtrAlloc( Vec_IntSize(vNodes) ); Wlc_NtkForEachObjVec( vNodes, p, pWlcObj, i ) { nBits = Wlc_ObjRange(pWlcObj); vOne = Vec_PtrAlloc( nBits ); for ( k = 0; k < nBits; k++ ) Vec_PtrPush( vOne, ABC_CALLOC(word, nWords * nFrames) ); Vec_PtrPush( vRes, vOne ); }
/**Function************************************************************* Synopsis [Start the truth table logging.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Tru_Man_t * Tru_ManAlloc( int nVars ) { word Masks[6] = { 0xAAAAAAAAAAAAAAAA, 0xCCCCCCCCCCCCCCCC, 0xF0F0F0F0F0F0F0F0, 0xFF00FF00FF00FF00, 0xFFFF0000FFFF0000, 0xFFFFFFFF00000000 }; Tru_Man_t * p; int i, w; assert( nVars > 0 && nVars <= 16 ); p = ABC_CALLOC( Tru_Man_t, 1 ); p->nVars = nVars; p->nWords = (nVars < 6) ? 1 : (1 << (nVars-6)); p->nEntrySize = (sizeof(Tru_One_t) + p->nWords * sizeof(word))/sizeof(int); p->nTableSize = 8147; p->pTable = ABC_CALLOC( int, p->nTableSize ); p->pMem = Vec_SetAlloc( 16 ); // initialize truth tables p->pZero = ABC_ALLOC( word, p->nWords ); for ( i = 0; i < nVars; i++ ) { for ( w = 0; w < p->nWords; w++ ) if ( i < 6 ) p->pZero[w] = Masks[i]; else if ( w & (1 << (i-6)) ) p->pZero[w] = ~(word)0; else p->pZero[w] = 0; p->hIthVars[i] = Tru_ManInsert( p, p->pZero ); assert( !i || p->hIthVars[i] > p->hIthVars[i-1] ); } Tru_ManClear( p->pZero, p->nWords ); return p; }
ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Mpm_Man_t * Mpm_ManStart( Mig_Man_t * pMig, Mpm_Par_t * pPars ) { Mpm_Man_t * p; int i; assert( sizeof(Mpm_Uni_t) % sizeof(word) == 0 ); // aligned info to word boundary assert( pPars->nNumCuts <= MPM_CUT_MAX ); assert( !pPars->fUseTruth || pPars->pLib->LutMax <= 16 ); assert( !pPars->fUseDsd || pPars->pLib->LutMax <= 6 ); Mig_ManSetRefs( pMig ); // alloc p = ABC_CALLOC( Mpm_Man_t, 1 ); p->pMig = pMig; p->pPars = pPars; p->pLibLut = pPars->pLib; p->nLutSize = pPars->pLib->LutMax; p->nTruWords = pPars->fUseTruth ? Abc_Truth6WordNum(p->nLutSize) : 0; p->nNumCuts = pPars->nNumCuts; // cuts assert( Mpm_CutWordNum(32) < 32 ); // using 5 bits for word count p->pManCuts = Mmr_StepStart( 13, Abc_Base2Log(Mpm_CutWordNum(p->nLutSize) + 1) ); Vec_PtrGrow( &p->vFreeUnits, p->nNumCuts + 1 ); for ( i = p->nNumCuts; i >= 0; i-- ) Vec_PtrPush( &p->vFreeUnits, p->pCutUnits + i ); p->vTemp = Vec_PtrAlloc( 1000 ); // mapping attributes Vec_IntFill( &p->vCutBests, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vCutLists, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vMigRefs, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vMapRefs, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vEstRefs, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vRequireds, Mig_ManObjNum(pMig), ABC_INFINITY ); Vec_IntFill( &p->vTimes, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vAreas, Mig_ManObjNum(pMig), 0 ); Vec_IntFill( &p->vEdges, Mig_ManObjNum(pMig), 0 ); // start DSD manager assert( !p->pPars->fUseTruth || !p->pPars->fUseDsd ); if ( p->pPars->fUseTruth ) { p->vTtMem = Vec_MemAlloc( p->nTruWords, 12 ); // 32 KB/page for 6-var functions Vec_MemHashAlloc( p->vTtMem, 10000 ); p->funcCst0 = Vec_MemHashInsert( p->vTtMem, p->Truth ); Abc_TtUnit( p->Truth, p->nTruWords, 0 ); p->funcVar0 = Vec_MemHashInsert( p->vTtMem, p->Truth ); } else if ( p->pPars->fUseDsd ) { Mpm_ManPrecomputePerms( p ); p->funcVar0 = 1; } // finish p->timeTotal = Abc_Clock(); pMig->pMan = p; return p; }