private void computeEdgeRefs(DDEdge edge, RefGroup rg, int level, int dist) {
if (!edge.isDistanceKnown(level)) return;
int distance = edge.getDistance(level);
if (distance < 0) distance = -distance;
if (distance > dist) return;
long[] ddinfo = edge.getDDInfo();
for (int k = 0; k < ddinfo.length; k++)
if ((k != level)
&& DDInfo.isDistanceKnown(ddinfo[k])
&& (DDInfo.getDistance(ddinfo[k]) != 0)) {
rg.add(edge);
break;
}
}
private int[][] getDDVec(Table<Declaration, SubscriptExpr> arrayRefs, int loopDepth) {
if (arrayRefs == null) return new int[0][0];
int numEdges = 0;
Stack<DDEdge> wl = WorkArea.<DDEdge>getStack("g<SubscriptExpr>etDDVec");
Enumeration<DDEdge> k = graph.getEdges();
while (k.hasMoreElements()) { // Check out every array variable in the loop nest.
DDEdge edge = k.nextElement();
if (edge.isSpatial()) continue;
if (edge.isLoopIndependentDependency()) continue;
if (edge.representsAllInput()) continue;
wl.push(edge);
numEdges++;
}
int[][] DDVector = new int[numEdges][loopDepth];
int i = 0;
while (!wl.empty()) {
DDEdge edge = wl.pop();
if (trace) System.out.println(" edge " + edge);
// Find dependence distance.
for (int level = 1; level <= loopDepth; level++)
DDVector[i][level - 1] = edge.getDistance(level);
if (trace) {
System.out.print(i);
System.out.print(" ");
System.out.println(edge);
}
i++;
}
WorkArea.<DDEdge>returnStack(wl);
return DDVector;
}
/**
* Compute the reference groups for this loop. Two array references are in the same group with
* respect to this loop if - there is a loop-independent dependence between them, or - the
* dependence distance(dependence vector entry dl) for this loop is less than some constant
* *dist*, and all other dependence vector entries are 0. - the two array refer to the same array
* and differ by at most *dist2* in the first subscript dimension, where d is less than or equal
* to the cache line size in terms of array elements. All other subscripts must be identical.
* Notes: Here we assume dist1 = dist2 = 2
*/
private void computeRefGroups(
int level,
int dist1,
int dist2,
Table<Declaration, SubscriptExpr> arrayRefs,
Vector<RefGroup> refGroups) {
if (arrayRefs == null) return;
Enumeration<Declaration> ek = arrayRefs.keys();
while (ek.hasMoreElements()) {
VariableDecl vd = (VariableDecl) ek.nextElement();
String s = vd.getName(); // array name
Object[] v = arrayRefs.getRowArray(vd); // vector of SubscriptExpr's
int vi = v.length;
for (int j = vi - 1; j >= 0; j--) {
SubscriptExpr sr = (SubscriptExpr) v[j];
Vector<LoopHeaderChord> allRelatedLoops =
sr.allRelatedLoops(); // ** Incorrect when something like a[(j+i][j]
int arls = allRelatedLoops.size();
int firstsub = arls - 1; // ** Making an invalid assumption here
// Process the list of references r' with which r has a data
// dependence, and r is the source(data flows from r to r').
RefGroup rg = new RefGroup(s, sr);
Object[] edges = graph.getEdges(sr);
int len = edges.length;
for (int i = 0; i < len; i++) {
DDEdge edge = (DDEdge) edges[i];
if (edge.isSpatial()) continue;
// Condition(1)-(a) in McKinley's paper
if (edge.isLoopIndependentDependency()) { // add rP to the RefGroup of r:
rg.add(edge);
continue;
}
// Condition(1)-(b) in McKinley's paper
computeEdgeRefs(edge, rg, level, dist1);
if (arls <= 0) continue;
// Condition(2) in McKinley's paper
// rlevel is the level of the loop related to the first subscript.
int rlevel = allRelatedLoops.elementAt(firstsub).getNestedLevel();
computeEdgeRefs(edge, rg, rlevel, dist2);
}
boolean isInExistingRefGroups = false;
int rgl = refGroups.size();
for (int i = 0; i < rgl; i++) {
RefGroup rg2 = refGroups.elementAt(i);
if (!rg2.getName().equals(s)) continue;
isInExistingRefGroups = rg2.contains(rg);
if (isInExistingRefGroups) {
rg2.add(rg);
break;
}
}
if (!isInExistingRefGroups) refGroups.addElement(rg);
}
}
}