/* for each s*_red that intersects s*, reports the intersection of s*_red with s* and the intersections of s*_red with all other s*_blue to left of that intersection */ void TrapezoidSweep::advance(segment* s) { segment* s_red; segment* s_blue; if (s == &NULL_SEGMENT) return; // for dir from {+1,-1}... int repeat = 1; for (int dir = 1; repeat >= 0; dir = -1) { s_red = search(L_red, s, dir); for (;(s_red->x0 < meet(*s_red, *s)) && (meet(*s_red, *s) < x_sweep);) { s_blue = s; for (;(s_red->x0 < meet(*s_red, *s_blue)) && (meet(*s_red, *s_blue) < x_sweep) && (s_blue != &NULL_SEGMENT);) { report(s_red, s_blue); s_blue = next(L_blue, s_blue, -dir); } s_red->x0 = x0_red = meet(*s_red, *s); s_red = next(L_red, s_red, dir); } --repeat; } }
static void * thread_c( void UNUSED(*dummy)) { skDQErr_t err; meet(); INFOMSG("**** Test 1 ****"); err = skDequePushFront(da, (void*)xa); XASSERT(err == SKDQ_SUCCESS); starta(); meet(); INFOMSG("**** Test 2 ****"); starta(); SLEEP(1); err = skDequePushFront(da, (void*)xa); XASSERT(err == SKDQ_SUCCESS); meet(); INFOMSG("**** Test 3 ****"); starta(); SLEEP(1); startb(); SLEEP(1); err = skDequePushFront(da, (void*)xa); XASSERT(err == SKDQ_SUCCESS); err = skDequePushFront(da, (void*)xb); XASSERT(err == SKDQ_SUCCESS); meet(); XASSERT(resulta == 1 && resultb == 1); /* End */ starta(); startb(); return NULL; }
static RangeCheckSet* SetsMeet(ListRCS* sets, RangeCheckSet*(*meet)(RangeCheckSet*, RangeCheckSet*)) { if (sets->size() == 0) return new RangeCheckSet(); RangeCheckSet* lastSet = *(sets->begin()); for(std::list<RangeCheckSet*>::iterator II = sets->begin(), IE = sets->end(); II != IE; II++) { RangeCheckSet* currentSet = meet(lastSet, *II); lastSet = currentSet; } return lastSet; }
void roboMeet() { bool reachedZero = false; while( !meet() ) { if(reachedZero) { moveLeft(); moveLeft(); } else { moveLeft(); moveLeft(); moveRight(); } if( at-zero() ) { reachedZero = true; } } }
int update(ENVELOPE *env, POINT *p, FUNBAG *lpdf, METROPOLIS *metrop) /* to update envelope to incorporate new point on log density*/ /* *env : envelope attributes */ /* *p : point to be incorporated */ /* *lpdf : to evaluate log-density */ /* *metrop : for metropolis step */ { POINT *m,*ql,*qr,*q; if(!(p->f) || (env->cpoint > env->npoint - 2)){ /* y-value has not been evaluated or no room for further points */ /* ignore this point */ return 0; } /* copy working POINT p to a new POINT q */ q = env->p + env->cpoint++; q->x = p->x; q->y = p->y; q->f = 1; /* allocate an unused POINT for a new intersection */ m = env->p + env->cpoint++; m->f = 0; if((p->pl->f) && !(p->pr->f)){ /* left end of piece is on log density; right end is not */ /* set up new intersection in interval between p->pl and p */ m->pl = p->pl; m->pr = q; q->pl = m; q->pr = p->pr; m->pl->pr = m; q->pr->pl = q; } else if (!(p->pl->f) && (p->pr->f)){ /* left end of interval is not on log density; right end is */ /* set up new intersection in interval between p and p->pr */ m->pr = p->pr; m->pl = q; q->pr = m; q->pl = p->pl; m->pr->pl = m; q->pl->pr = q; } else { /* this should be impossible */ exit(10); } /* now adjust position of q within interval if too close to an endpoint */ if(q->pl->pl != NULL){ ql = q->pl->pl; } else { ql = q->pl; } if(q->pr->pr != NULL){ qr = q->pr->pr; } else { qr = q->pr; } if (q->x < (1. - XEPS) * ql->x + XEPS * qr->x){ /* q too close to left end of interval */ q->x = (1. - XEPS) * ql->x + XEPS * qr->x; q->y = perfunc(lpdf,env,q->x); } else if (q->x > XEPS * ql->x + (1. - XEPS) * qr->x){ /* q too close to right end of interval */ q->x = XEPS * ql->x + (1. - XEPS) * qr->x; q->y = perfunc(lpdf,env,q->x); } /* revise intersection points */ if(meet(q->pl,env,metrop)){ /* envelope violation without metropolis */ return 1; } if(meet(q->pr,env,metrop)){ /* envelope violation without metropolis */ return 1; } if(q->pl->pl != NULL){ if(meet(q->pl->pl->pl,env,metrop)){ /* envelope violation without metropolis */ return 1; } } if(q->pr->pr != NULL){ if(meet(q->pr->pr->pr,env,metrop)){ /* envelope violation without metropolis */ return 1; } } /* exponentiate and integrate new envelope */ cumulate(env); return 0; }
int initial (double *xinit, int ninit, double xl, double xr, int npoint, FUNBAG *lpdf, ENVELOPE *env, double *convex, int *neval, METROPOLIS *metrop) /* to set up initial envelope */ /* xinit : initial x-values */ /* ninit : number of initial x-values */ /* xl,xr : lower and upper x-bounds */ /* npoint : maximum number of POINTs allowed in envelope */ /* *lpdf : to evaluate log density */ /* *env : rejection envelope attributes */ /* *convex : adjustment for convexity */ /* *neval : current number of function evaluations */ /* *metrop : for metropolis step */ { int i,j,k,mpoint; POINT *q; if(ninit<3){ /* too few initial points */ return 1001; } mpoint = 2*ninit + 1; if(npoint < mpoint){ /* too many initial points */ return 1002; } if((xinit[0] <= xl) || (xinit[ninit-1] >= xr)){ /* initial points do not satisfy bounds */ return 1003; } for(i=1; i<ninit; i++){ if(xinit[i] <= xinit[i-1]){ /* data not ordered */ return 1004; } } if(*convex < 0.0){ /* negative convexity parameter */ return 1008; } /* copy convexity address to env */ env->convex = convex; /* copy address for current number of function evaluations */ env->neval = neval; /* initialise current number of function evaluations */ *(env->neval) = 0; /* set up space for envelope POINTs */ env->npoint = npoint; env->p = (POINT *)malloc(npoint*sizeof(POINT)); if(env->p == NULL){ /* insufficient space */ return 1006; } /* set up envelope POINTs */ q = env->p; /* left bound */ q->x = xl; q->f = 0; q->pl = NULL; q->pr = q+1; for(j=1, k=0; j<mpoint-1; j++){ q++; if(j%2){ /* point on log density */ q->x = xinit[k++]; q->y = perfunc(lpdf,env,q->x); q->f = 1; } else { /* intersection point */ q->f = 0; } q->pl = q-1; q->pr = q+1; } /* right bound */ q++; q->x = xr; q->f = 0; q->pl = q-1; q->pr = NULL; /* calculate intersection points */ q = env->p; for (j=0; j<mpoint; j=j+2, q=q+2){ if(meet(q,env,metrop)){ /* envelope violation without metropolis */ return 2000; } } /* exponentiate and integrate envelope */ cumulate(env); /* note number of POINTs currently in envelope */ env->cpoint = mpoint; return 0; }
// Test for higher or equal in lattice int higher_equal( const Type *t ) const { return !cmp(meet(t),t); }
OA_ptr<DataFlow::DataFlowSet> ManagerDepStandard::transfer(OA_ptr<DataFlow::DataFlowSet> in, OA::StmtHandle stmt) { OA_ptr<DepDFSet> inRecast = in.convert<DepDFSet>(); if (debug) { std::cout << "In transfer, stmt(hval=" << stmt.hval() << ")= "; mIR->dump(stmt,std::cout); std::cout << "\tinRecast = "; inRecast->dump(std::cout,mIR); } // new DepDFSet for this stmt OA_ptr<DepDFSet> stmtDepDFSet; stmtDepDFSet = new DepDFSet; // set of must defs and differentiable uses for this statement LocSet mustDefSet; LocSet mayDefSet; LocSet diffUseSet; // set of expressions to analyze for differentiable uses std::set<ExprHandle> exprSet; OA_ptr<AssignPairIterator> espIterPtr = mIR->getAssignPairIterator(stmt); if(!espIterPtr.ptrEqual(0)) { for ( ; espIterPtr->isValid(); ++(*espIterPtr)) { // unbundle pair MemRefHandle mref = espIterPtr->currentTarget(); ExprHandle expr = espIterPtr->currentSource(); if (debug) { std::cout << "\tmref = " << mIR->toString(mref) << ", "; std::cout << "expr = " << mIR->toString(expr) << std::endl; } // add this to list of expressions we need to analyze exprSet.insert(expr); if (debug) { std::cout << "Inserting memref = expr into exprSet" << std::endl; OA_ptr<ExprTree> etree = mIR->getExprTree(expr); etree->dump(std::cout,mIR); } // keep track of def mustlocs OA_ptr<LocIterator> locIterPtr = mAlias->getMustLocs(mref); for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) { mustDefSet.insert(locIterPtr->current()); } // maylocs need to be used for Dep pairs so that we get // conservative activity results locIterPtr = mAlias->getMayLocs(mref); for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) { mayDefSet.insert(locIterPtr->current()); } } // all other statement types just get all uses and defs } else { if (debug) { std::cout << "\tstmt is not EXPR_STMT, stmt = "; } OA_ptr<MemRefHandleIterator> mrIterPtr = mIR->getUseMemRefs(stmt); for (; mrIterPtr->isValid(); (*mrIterPtr)++ ) { MemRefHandle mref = mrIterPtr->current(); OA_ptr<LocIterator> locIterPtr = mAlias->getMayLocs(mref); for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) { diffUseSet.insert(locIterPtr->current()); } } mrIterPtr = mIR->getDefMemRefs(stmt); for (; mrIterPtr->isValid(); (*mrIterPtr)++ ) { MemRefHandle mref = mrIterPtr->current(); OA_ptr<LocIterator> locIterPtr = mAlias->getMustLocs(mref); for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) { mustDefSet.insert(locIterPtr->current()); } locIterPtr = mAlias->getMayLocs(mref); for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) { mayDefSet.insert(locIterPtr->current()); } } } // iterate over all calls in the statement // and union use,def pairs for the call into DepDFSet for // the current stmt // also find all expressions that are callsite params and not // reference parameters OA_ptr<IRCallsiteIterator> callsiteItPtr = mIR->getCallsites(stmt); for ( ; callsiteItPtr->isValid(); ++(*callsiteItPtr)) { CallHandle call = callsiteItPtr->current(); if (debug) { std::cout << "\nhandling all callsite params and side-effects, "; std::cout << "call = " << mIR->toString(call) << std::endl; } // get DepDFSet results for this call and put them in results // for this stmt, will do meet with procedure DepDFSet at end OA_ptr<DepDFSet> callDepDFSet = mInterDep->getDepForCall(call); if (debug) { std::cout << "meet involving call DepDFSet" << std::endl; // callDepDFSet->dump(std::cout,mIR); } OA_ptr<DataFlow::DataFlowSet> tmp = meet(stmtDepDFSet,callDepDFSet); stmtDepDFSet = tmp.convert<DepDFSet>(); if (debug) { std::cout << "\tstmtDepDFSet after meet with callDepDFSet = "; //stmtDepDFSet->dump(std::cout, mIR); } // looping over actual params OA_ptr<IRCallsiteParamIterator> cspIterPtr = mIR->getCallsiteParams(call); for ( ; cspIterPtr->isValid(); ++(*cspIterPtr)) { ExprHandle param = cspIterPtr->current(); // determine if dealing with a reference parameter bool isRefParam = false; OA_ptr<ExprTree> eTreePtr = mIR->getExprTree(param); EvalToMemRefVisitor evalVisitor; eTreePtr->acceptVisitor(evalVisitor); if (debug) { eTreePtr->dump(std::cout,mIR); } if ( evalVisitor.isMemRef() ) { MemRefHandle memref = evalVisitor.getMemRef(); assert(0); // need to rewrite alg, see MMS //if (mParamBind->isRefParam( // mParamBind->getCalleeFormal(call,memref)) ) //{ // isRefParam = true; // } } // record expr for those that aren't reference parameters if (isRefParam==false) { exprSet.insert(param); if (debug) { std::cout << "Inserting param expr into exprSet" << std::endl; eTreePtr->dump(std::cout,mIR); } } } } // get differentiable locations from all expressions in stmt if (debug) { std::cout << "ExprTree's:" << std::endl; } DifferentiableLocsVisitor dlVisitor(mAlias); std::set<ExprHandle>::iterator exprIter; for (exprIter=exprSet.begin(); exprIter!=exprSet.end(); exprIter++) { OA_ptr<ExprTree> etree = mIR->getExprTree(*exprIter); if (debug) { etree->dump(std::cout,mIR); } etree->acceptVisitor(dlVisitor); OA_ptr<LocIterator> locIterPtr = dlVisitor.getDiffLocsIterator(); for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) { diffUseSet.insert(locIterPtr->current()); } } // store must defs in Dep results as well // and remove the associated implicit dep from DepDFSet LocSet::iterator useIter, defIter; for (defIter=mustDefSet.begin(); defIter!=mustDefSet.end(); defIter++) { mDep->insertMustDefForStmt(stmt,*defIter); stmtDepDFSet->removeImplicitDep(*defIter,*defIter); } // map all uses to may defs and vice versa for this statement // have to do this after removing implicit deps in case it will be // explicitly put back in OA_ptr<Location> use, def; for (useIter=diffUseSet.begin(); useIter!=diffUseSet.end(); useIter++) { for (defIter=mayDefSet.begin(); defIter!=mayDefSet.end(); defIter++) { stmtDepDFSet->insertDep(*useIter,*defIter); } } // map stmtDepDFSet to stmt in depResults mDep->mapStmtToDeps(stmt, stmtDepDFSet); //// compose the DepDFSet for this stmt with one coming in // make a copy of inRecast so we don't overwrite IN OA_ptr<DepDFSet> tmpCopy; tmpCopy = new DepDFSet(*inRecast); (*tmpCopy) = tmpCopy->compose(*stmtDepDFSet); //OA_ptr<DepDFSet> tmpCopy; //tmpCopy = inRecast->compose(stmtDepDFSet); if (debug) { std::cout << "\tManagerDepStandard::transfer, returning tmpCopy = "; tmpCopy->dump(std::cout,mIR); std::cout << "\t------ other dump" << std::endl; tmpCopy->dump(std::cout); } return tmpCopy; }
//-------------------------------------------------------- // solver upcalls //-------------------------------------------------------- bool CFGDFProblem::atDGraphNode( OA_ptr<DGraph::CFGInterface::NodeInterface> pNode, DGraph::DGraphEdgeDirection pOrient) { bool changed = false; OA_ptr<CFG::CFGInterface::NodeIterface> node = pNode.convert<OA::CFG::CFGInterface::NodeInterface>(); if (debug) { std::cout << "CFGDFProblem::atDGraphNode: CFG node = "; std::cout << node->getId() << std::endl; } //----------------------------------------------------- // do a meet of all out information from nodes that are // predecessors based on the flow direction //----------------------------------------------------- OA_ptr<DataFlowSet> meetPartialResult = mTop->clone(); // added following for ReachConsts, should not bother other flows // because DFProblem has monotonicity meetPartialResult = meet(meetPartialResult,mNodeInSetMap[node]); // set up iterator for predecessor nodes OA_ptr<CFG::CFGInterface::NodesIteratorInterface> predIterPtr; if (pOrient==DGraph::DEdgeOrg) { OA_ptr<CFG::CFGInterface::NodesIteratorInterface> it = node->getPredNodesIterator(); // Stupid Sun CC 5.4 predIterPtr = it.convert<CFG::CFGInterface::NodesIteratorInterface>(); } else { OA_ptr<CFG::CFGInterface::NodesIteratorInterface> it = node->getSuccNodesIterator(); // Stupid Sun CC 5.4 predIterPtr = it.convert<CFG::CFGInterface::NodesIteratorInterface>(); } // iterate over predecessors and do meet operation for (; predIterPtr->isValid(); ++(*predIterPtr)) { OA_ptr<CFG::CFGInterface::NodeInterface> predNode = predIterPtr->current(); if (pOrient==DGraph::DEdgeOrg) { meetPartialResult = meet(meetPartialResult, mNodeOutSetMap[predNode]); } else { meetPartialResult = meet(meetPartialResult, mNodeInSetMap[predNode]); } } // update the appropriate set for this node if (pOrient==DGraph::DEdgeOrg) { // forward if ( mNodeInSetMap[node] != meetPartialResult ) { if (debug) { std::cout << "%%%%%%%% CFGDFProblem: There was a change" << std::endl; std::cout << "\tmNodeInSetMap != meetPartialResult" << std::endl; } mNodeInSetMap[node] = meetPartialResult; changed = true; } } else { // reverse if ( mNodeOutSetMap[node] != meetPartialResult ) { mNodeOutSetMap[node] = meetPartialResult; changed = true; } } // if the data flowing into this node has changed or if the // transfer functions have never been applied, then // loop through statements in the CFG node/(Basic Block) // calculating the new node out if (debug) { std::cout << "\tchanged = " << changed << ", mNITA[node]=" << mNodeInitTransApp[node] << std::endl; } if (changed || !mNodeInitTransApp[node]) { changed = false; // reuse to determine if there is a change based // on the block transfer function mNodeInitTransApp[node] = true; // Forward direction if (pOrient==DGraph::DEdgeOrg) { OA_ptr<DataFlowSet> prevOut = mNodeInSetMap[node]->clone(); // loop through statements in forward order if (debug) { std::cout << "CFGDFProblem: iterating over statements in node"; std::cout << std::endl; } OA_ptr<CFG::CFG::NodeStatementsIterator> stmtIterPtr = node->getNodeStatementsIterator(); for (; stmtIterPtr->isValid(); ++(*stmtIterPtr)) { OA::StmtHandle stmt = stmtIterPtr->current(); if (debug) { std::cout << "\tstmt(hval=" << stmt.hval() << ")" << std::endl; } prevOut = transfer(prevOut, stmt); } if (debug) { std::cout << "CFGDFProblem: done iterating over statements"; std::cout << std::endl; } if (prevOut != mNodeOutSetMap[node] ) { changed = true; mNodeOutSetMap[node] = prevOut; if (debug) { std::cout << "%%%%%%%% CFGDFProblem: There was a change" << std::endl; std::cout << "\tmNodeOutSetMap != prevOut" << std::endl; } } // Reverse direction } else { OA_ptr<DataFlowSet> prevIn = mNodeOutSetMap[node]->clone(); // loop through statements in reverse order OA_ptr<CFG::CFG::NodeStatementsRevIterator> stmtIterPtr = node->getNodeStatementsRevIterator(); for (; stmtIterPtr->isValid(); ++(*stmtIterPtr)) { OA::StmtHandle stmt = stmtIterPtr->current(); prevIn = transfer(prevIn, stmt); } if (prevIn != mNodeInSetMap[node] ) { changed = true; mNodeInSetMap[node] = prevIn; } } } if (debug) { std::cout << "CFGDFProblem::atDGraphNode: changed = " << changed << std::endl; } return changed; }