-// Copyright 2006 all rights reserved; see LICENSE file for BSD-style license
+// Copyright 2006-2007 all rights reserved; see LICENSE file for BSD-style license
package edu.berkeley.sbp;
import edu.berkeley.sbp.*;
import edu.berkeley.sbp.util.*;
import edu.berkeley.sbp.Parser.Table.*;
import edu.berkeley.sbp.Sequence.Position;
+import edu.berkeley.sbp.Sequence.Pos;
import java.io.*;
import java.util.*;
import java.lang.reflect.*;
class Phase<Tok> implements Invokable<State, Result>, IntegerMappable, GraphViz.ToGraphViz, Iterable<Node> {
// FIXME: right now, these are the performance bottleneck
- private HashMapBag<Integer,Sequence> performed = new HashMapBag<Integer,Sequence>();
+ private HashMapBag<Integer,Integer> performed = new HashMapBag<Integer,Integer>();
public Forest.Many finalResult;
private PriorityQueue<Reduction> reductionQueue = new PriorityQueue<Reduction>();
numReductions = 0;
int minPhasePos = Integer.MAX_VALUE;
- int maxOrd = -1;
Reduction best = null;
//System.out.println("==============================================================================");
while(!reductionQueue.isEmpty()) {
if (r.parentPhase() != null) {
if (r.parentPhase().pos < minPhasePos) {
minPhasePos = r.parentPhase().pos;
- maxOrd = r.reduction().ord;
best = r;
} else if (r.parentPhase().pos == minPhasePos) {
/*
Parser.mastercache.comparePositions(r.reduction(), best.reduction())+"\n"+r.compareTo(best)+
"\n"+(r.reduction().ord-best.reduction().ord));
*/
- maxOrd = r.reduction().ord;
best = r;
}
}
return getLocation().createRegion(getNextLocation());
}
- void newNodeFromReduction(Result result, State state, Position reduction) {
+ void newNodeFromReduction(Result result, State state, Pos reduction) {
int pos = result.phase().pos;
- Sequence owner = reduction.owner();
- for(Sequence s : owner.hates())
+ for(int s : reduction.hates())
if (performed.contains(pos, s))
return;
- for(Sequence s : owner.needs())
+ for(int s : reduction.needs())
if (!performed.contains(pos, s))
return;
- if (owner.needed_or_hated && !performed.contains(pos, owner))
- performed.add(pos, owner);
+ if (reduction.owner_needed_or_hated() && !performed.contains(pos, reduction.provides()))
+ performed.add(pos, reduction.provides());
if (state!=null)
- newNode(result, state, reduction.pos<=0);
+ newNode(result, state, reduction.numPops()<=0);
}
/** add a new node (merging with existing nodes if possible)