private Bound(Expression min, Expression max) {
this.flags = NORMAL;
setMin(min);
setMax(max);
if (bounds == null) bounds = new Vector<Bound>(10);
bounds.addElement(this);
}
public void add(RefGroup r) {
int l = r.refs.size();
for (int i = 0; i < l; i++) {
Object ref = r.refs.elementAt(i);
if (!refs.contains(ref)) refs.addElement(ref);
}
}
/** Add the flags necessary for the C preprocessor. */
public void addCPPFlags(Vector<String> v) {
v.addElement("__i386__=1");
}
public static ArrayList<Vector> AprMainLoop(
ArrayList<Vector> vec, double minSupp, boolean skyLine) {
ArrayList<Vector> answer = new ArrayList<Vector>();
// get frequent itemset size of 1
ArrayList<Item> freqItem = firstPass(vec, minSupp);
// System.out.println("Frequent itemset size of 1 are: "+freqItem.toString());
int largestItemSetSize = freqItem.size();
// System.out.println("Largest item set size: "+largestItemSetSize);
// make a item group of 1 from frequent item lists
ArrayList<ArrayList<Item>> itemGroups = new ArrayList<ArrayList<Item>>();
for (int itemIdx = 0; itemIdx < freqItem.size(); itemIdx++) {
ArrayList<Item> temp = new ArrayList<Item>();
temp.add(freqItem.get(itemIdx));
itemGroups.add(temp);
}
ArrayList<ArrayList<Item>> tempCandidate = new ArrayList<ArrayList<Item>>(itemGroups);
// main loop
for (int itemSize = 1; itemSize < largestItemSetSize; itemSize++) {
// candidate frequent itemsets
if (tempCandidate.size() == 0) {
break;
}
itemGroups = candidateGen(tempCandidate, itemSize);
// initialize counts
int[] groupFreqAr = new int[itemGroups.size()];
// for each receipt
for (int vecIdx = 0; vecIdx < vec.size(); vecIdx++) {
// for every item number
for (int itemGroupsIdx = 0; itemGroupsIdx < itemGroups.size(); itemGroupsIdx++) {
if (vecContainsItems(vec.get(vecIdx), itemGroups.get(itemGroupsIdx))) {
groupFreqAr[itemGroupsIdx]++;
// System.out.println("Match at "+vec.get(vecIdx).getElement(0)+" for
// "+itemGroups.get(itemGroupsIdx));
}
}
}
tempCandidate = new ArrayList<ArrayList<Item>>();
// go through the array with counts of the frequency of set of groups
// and add it to the final return AL of vector if the item group is
// above minSupp
for (int groupIdx = 0; groupIdx < itemGroups.size(); groupIdx++) {
double supp = (double) groupFreqAr[groupIdx] / (double) vec.size();
// System.out.println("support for "+itemGroups.get(groupIdx)+" is "+supp);
if (supp > minSupp) {
// System.out.println("support for "+itemGroups.get(groupIdx)+" is "+supp);
Vector temp = new Vector();
tempCandidate.add(new ArrayList<Item>());
for (int itemIdx = 0; itemIdx < itemGroups.get(groupIdx).size(); itemIdx++) {
temp.addElement(itemGroups.get(groupIdx).get(itemIdx).itemID);
tempCandidate.get(tempCandidate.size() - 1).add(itemGroups.get(groupIdx).get(itemIdx));
}
temp.setSupport(supp);
answer.add(temp);
}
}
}
if (skyLine) {
return skyLine(answer);
} else {
return answer;
}
}
/**
* 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);
}
}
}
public void add(DDEdge edge) {
if (refs.contains(edge)) return;
refs.addElement(edge);
}
public RefGroup(String name, SubscriptExpr r) {
this.refs = new Vector<Object>();
this.aname = name;
refs.addElement(r);
}
public void addParam(Parameter p) {
d_params.addElement(p);
}
