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