/** This function calls analysis for every node in a method */
private void doFlatNodeAnalysis(FlatMethod fm) {
tovisit = fm.getNodeSet(); //Flat nodes to process
+ Hashtable<PrefetchPair, Float> nodehash = new Hashtable<PrefetchPair, Float>();
+ /* Create Empty Prefetch Sets for all flat nodes in the global hashtable */
while(!tovisit.isEmpty()) {
FlatNode fn = (FlatNode)tovisit.iterator().next();
- /* Generate self node prefetch pairs */
- doNodePrefetch(fn);
- /* Generate prefetch pairs after the child node analysis */
- boolean curr_modified = doNodeChildPrefetch(fn);
+ prefetch_hash.put(fn, nodehash);
tovisit.remove(fn);
}
- }
-
- /**
- * This function generates initial prefetch pair for a Flat node that is of the
- * following kind FlatFieldNode, FlatElementNode, FlatSetFieldNode or FlatSetElementNode
- * */
- private void doNodePrefetch(FlatNode fn) {
- Hashtable<PrefetchPair, Float> nodehash = new Hashtable<PrefetchPair, Float>();
- switch(fn.kind()) {
- case FKind.FlatFieldNode:
- FlatFieldNode currffn = (FlatFieldNode) fn;
- FieldDescriptor currffn_field = currffn.getField();
- TempDescriptor currffn_src = currffn.getSrc();
- if (currffn_field.getType().isPtr()) {
- Boolean b = new Boolean(false);
- PrefetchPair pp = new PrefetchPair(currffn_src, (Descriptor) currffn_field, b);
- Float prob = new Float((float)1.0);
- nodehash.put(pp, prob);
- prefetch_hash.put(fn, nodehash);
- }
- break;
- case FKind.FlatElementNode:
- FlatElementNode currfen = (FlatElementNode) fn;
- TempDescriptor currfen_index = currfen.getIndex();
- TempDescriptor currfen_src = currfen.getSrc();
- if(currfen.getDst().getType().isPtr()) {
- PrefetchPair pp = new PrefetchPair(currfen_src, (Descriptor) currfen_index, true);
- Float prob = new Float((float)1.0);
- nodehash.put(pp, prob);
- prefetch_hash.put(fn, nodehash);
- }
- break;
- case FKind.FlatSetFieldNode:
- FlatSetFieldNode currfsfn = (FlatSetFieldNode) fn;
- TempDescriptor currfsfn_src = currfsfn.getSrc();
- if (currfsfn_src.getType().isPtr()) {
- PrefetchPair pp = new PrefetchPair(currfsfn_src);
- Float prob = new Float((float)1.0);
- nodehash.put(pp, prob);
- prefetch_hash.put(fn, nodehash);
- }
- break;
- case FKind.FlatSetElementNode:
- FlatSetElementNode currfsen = (FlatSetElementNode) fn;
- TempDescriptor currfsen_src = currfsen.getSrc();
- if (currfsen_src.getType().isPtr()) {
- PrefetchPair pp = new PrefetchPair(currfsen_src);
- Float prob = new Float((float)1.0);
- nodehash.put(pp, prob);
- prefetch_hash.put(fn, nodehash);
- }
- break;
- default:
- break;
+ tovisit = fm.getNodeSet(); //Flat nodes to process
+ while(!tovisit.isEmpty()) {
+ FlatNode fn = (FlatNode)tovisit.iterator().next();
+ /* Generate prefetch pairs after the child node analysis */
+ boolean curr_modified = doChildNodeAnalysis(fn);
+ tovisit.remove(fn);
}
}
* returns true: if the prefetch set has changed since last time the node was analysed
* returns false : otherwise
*/
- private boolean doNodeChildPrefetch(FlatNode curr) {
- boolean ppSetHasChanged = false;
+ private boolean doChildNodeAnalysis(FlatNode curr) {
+ boolean pSetHasChanged = false;
Hashtable<PrefetchPair, Float> child_hash = new Hashtable<PrefetchPair, Float>();
for (int i = 0; i < curr.numNext(); i++) {
FlatNode child_node = curr.getNext(i);
}
switch(curr.kind()) {
case FKind.FlatFieldNode:
- if(prefetch_hash.containsKey(curr)) {
- processFlatFieldNode(curr, child_hash);
- } else {
- prefetch_hash.put(curr, child_hash);
- }
+ processFlatFieldNode(curr, child_hash);
break;
case FKind.FlatElementNode:
- if(prefetch_hash.containsKey(curr)) {
- processFlatElementNode(curr, child_hash);
- } else {
- prefetch_hash.put(curr, child_hash);
- }
- break;
- case FKind.FlatCall:
- //processFlatCallNode();
+ processFlatElementNode(curr, child_hash);
break;
case FKind.FlatCondBranch:
//processFlatCondBranchNode();
break;
case FKind.FlatNew:
- //processFlatNewNode();
+ //processFlatNewNode(curr, child_hash);
break;
case FKind.FlatOpNode:
- //processFlatOpNode();
+ processFlatOpNode(curr, child_hash);
break;
case FKind.FlatSetElementNode:
- //processFlatSetElementNode();
+ processFlatSetElementNode(curr, child_hash);
break;
case FKind.FlatSetFieldNode:
- //processFlatSetFieldNode();
+ processFlatSetFieldNode(curr, child_hash);
break;
default:
/*If FlatNode is not concerned with the prefetch set of its Child then propagate
* prefetches up the FlatNode*/
- //TODO make this a new method
- if(prefetch_hash.containsKey(curr)) {
- Hashtable<PrefetchPair, Float> currcopy = (Hashtable<PrefetchPair,Float>)prefetch_hash.get(curr).clone();
- Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
- Enumeration e = currcopy.keys();
- while (e.hasMoreElements()) {
- PrefetchPair pp = (PrefetchPair) e.nextElement();
- if (child_hash.contains(pp)) {
- Float cprob = child_hash.get(pp);
- Float fprob = currcopy.get(pp);
- // TODO fix this
- Float newprob = cprob.floatValue() * fprob.floatValue();
- tocompare.put(pp, newprob);
- child_hash.remove(pp);
- } else {
- tocompare.put(pp, currcopy.get(pp));
- }
- }
- for(e = child_hash.keys(); e.hasMoreElements();) {
- PrefetchPair newpp = (PrefetchPair) e.nextElement();
- tocompare.put(newpp, child_hash.get(newpp));
- }
- /* Compare with old Prefetch sets */
- ppSetHasChanged = comparePrefetchSets(currcopy, tocompare);
+ Enumeration e = null;
+ Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
+ for(e = child_hash.keys(); e.hasMoreElements();) {
+ PrefetchPair newpp = (PrefetchPair) e.nextElement();
+ tocompare.put(newpp, child_hash.get(newpp));
+ }
- } else {
- /* Add the child prefetch set to Curr FlatNode */
- prefetch_hash.put(curr, child_hash);
+ /* Compare with old Prefetch sets */
+ pSetHasChanged = comparePrefetchSets(prefetch_hash.get(curr), tocompare);
+ if(pSetHasChanged){
+ for(int j=0; j<curr.numPrev(); j++) {
+ tovisit.add(curr.getPrev(j));
+ }
+ /* Overwrite the new prefetch set to the global hash table */
+ prefetch_hash.put(curr,tocompare);
}
break;
}
}
- return ppSetHasChanged;
+ return pSetHasChanged;
}
/**This function compares all the prefetch pairs in a Prefetch set hashtable and
boolean hasChanged = false;
PrefetchPair oldpp = null;
PrefetchPair newpp = null;
+
if(oldPrefetchSet.size() != newPrefetchSet.size()) {
return true;
} else {
* If old prefetch set is not same as new prefetch set then enqueue the parents
* of the current FlatFieldNode
* */
- void processFlatFieldNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
+
private void processFlatFieldNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
boolean pSetHasChanged = false;
- Hashtable<PrefetchPair, Float> currcopy = (Hashtable<PrefetchPair,Float>) prefetch_hash.get(curr).clone();
+ Hashtable<PrefetchPair, Float> currcopy = new Hashtable<PrefetchPair, Float>();
Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
FlatFieldNode currffn = (FlatFieldNode) curr;
- Float newprob = new Float((float)1.0);
- //1.Get each prefetch pair of the child and match it with the destination temp descriptor of curr FlatFieldNode
+ /* Do Self analysis of the current node*/
+ FieldDescriptor currffn_field = currffn.getField();
+ TempDescriptor currffn_src = currffn.getSrc();
+ if (currffn_field.getType().isPtr()) {
+ Boolean b = new Boolean(false);
+ PrefetchPair pp = new PrefetchPair(currffn_src, (Descriptor) currffn_field, b);
+ Float prob = new Float((float)1.0);
+ currcopy.put(pp, prob);
+ }
+
+ /* Get each prefetch pair of the child and match it with the destination temp descriptor of curr FlatFieldNode */
Enumeration ecld = child_hash.keys();
PrefetchPair currpp = null;
PrefetchPair childpp = null;
childpp = (PrefetchPair) ecld.nextElement();
if (childpp.base == currffn.getDst() && (childpp.getDesc()!= null || childpp.getisTempDesc()!=null)) {
if (currffn.getField().getType().isPtr()) {
- //pSetHasChanged = true;
- //if match exists then create a new Prefetch set with the new prefetch pair in a new hash table
+ /* Create a new Prefetch set */
ArrayList<Descriptor> newdesc = new ArrayList<Descriptor>();
ArrayList<Boolean> newbool = new ArrayList<Boolean>();
newdesc.add(currffn.getField());
newdesc.addAll(childpp.desc);
newbool.addAll(childpp.isTempDesc);
PrefetchPair newpp = new PrefetchPair(currffn.getSrc(), newdesc, newbool);
+ Float newprob = child_hash.get(childpp).floatValue();
tocompare.put(newpp, newprob);
child_hash.remove(childpp);
+ /* Check for independence of prefetch pairs if any in the child prefetch set
+ * to compute new probability */
+ if(child_hash.containsKey(newpp)) {
+ newprob = (float)(1.0 - ((1.0 - child_hash.get(newpp).floatValue()) * (1.0 - tocompare.get(newpp).floatValue())));
+ tocompare.put(newpp, newprob);
+ child_hash.remove(newpp);
+ }
}
} else if(childpp.base == currffn.getDst() && (childpp.getDesc() == null ||
childpp.getisTempDesc() == null)) {
child_hash.remove(childpp);
+ } else {
+ continue;
}
}
/* Check if curr prefetch set and the child prefetch set have same prefetch pairs
for(e = currcopy.keys(); e.hasMoreElements();) {
currpp = (PrefetchPair) e.nextElement();
if(currpp.equals(childpp)) {
- /* Calculate the new probability */
- Float cprob = child_hash.get(childpp);
- Float fprob = currcopy.get(currpp);
- // TODO fix this
- Float prob = cprob.floatValue() * fprob.floatValue();
+ /* Probability of the incoming edge for a FlatFieldNode is always 100% */
+ Float prob = currcopy.get(currpp).floatValue();
currcopy.put(currpp, prob);
child_hash.remove(childpp);
break;
* It compares the old prefetch set with this new prefetch set and enqueues the parents
* of the current node if change occurs and updates the global flatnode hash table
* */
- void processFlatElementNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
+ private void processFlatElementNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
+
boolean pSetHasChanged = false;
- Hashtable<PrefetchPair, Float> currcopy = (Hashtable<PrefetchPair,Float>) prefetch_hash.get(curr).clone();
+ Hashtable<PrefetchPair, Float> currcopy = new Hashtable<PrefetchPair, Float>();
Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
FlatElementNode currfen = (FlatElementNode) curr;
- Float newprob = new Float((float)1.0);
+
+ /* Do Self analysis of the current node*/
+ TempDescriptor currfen_index = currfen.getIndex();
+ TempDescriptor currfen_src = currfen.getSrc();
+ if(currfen.getDst().getType().isPtr()) {
+ PrefetchPair pp = new PrefetchPair(currfen_src, (Descriptor) currfen_index, true);
+ Float prob = new Float((float)1.0);
+ currcopy.put(pp, prob);
+ }
/* Get each prefetch pair of the child and match it with the destination temp descriptor of curr FlatFieldNode */
Enumeration ecld = child_hash.keys();
childpp = (PrefetchPair) ecld.nextElement();
if (childpp.base == currfen.getDst() && (childpp.getDesc()!= null || childpp.getisTempDesc()!=null)) {
if (currfen.getDst().getType().isPtr()) {
- //if match exists then create a new Prefetch set with the new prefetch pair in a new hash table
+ //TODO Modify the Prefetch Pair to insert cases like f=a[i+1]
ArrayList<Descriptor> newdesc = new ArrayList<Descriptor>();
ArrayList<Boolean> newbool = new ArrayList<Boolean>();
newdesc.add(currfen.getIndex());
newdesc.addAll(childpp.desc);
newbool.addAll(childpp.isTempDesc);
PrefetchPair newpp = new PrefetchPair(currfen.getSrc(), newdesc, newbool);
+ Float newprob = child_hash.get(childpp).floatValue();
tocompare.put(newpp, newprob);
child_hash.remove(childpp);
+ /* Check for independence of prefetch pairs if any in the child prefetch set
+ * to compute new probability */
+ if(child_hash.containsKey(newpp)) {
+ newprob = (float)(1.0 - ((1.0 - child_hash.get(newpp).floatValue()) * (1.0 - tocompare.get(newpp).floatValue())));
+ tocompare.put(newpp, newprob);
+ child_hash.remove(newpp);
+ }
}
} else if(childpp.base == currfen.getDst() && (childpp.getDesc() == null ||
childpp.getisTempDesc() == null)) {
for(e = currcopy.keys(); e.hasMoreElements();) {
currpp = (PrefetchPair) e.nextElement();
if(currpp.equals(childpp)) {
- /* Calculate the new probability */
- Float cprob = child_hash.get(childpp);
- Float fprob = currcopy.get(currpp);
- // TODO fix this
- Float prob = cprob.floatValue() * fprob.floatValue();
+ /* Probability of the incoming edge for a FlatElementNode is always 100% */
+ Float prob = currcopy.get(currpp).floatValue();
currcopy.put(currpp, prob);
child_hash.remove(childpp);
break;
}
}
+ /** This function processes the prefetch set of a FlatSetFieldNode
+ * It generates a new prefetch set after comparision with its children
+ * It compares the old prefetch set with this new prefetch set and enqueues the parents
+ * of the current node if change occurs and then updates the global flatnode hash table
+ * */
+ private void processFlatSetFieldNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
+ boolean pSetHasChanged = false;
+ Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
+ FlatSetFieldNode currfsfn = (FlatSetFieldNode) curr;
+ PrefetchPair childpp = null;
+
+ /* Get each prefetch pair of the child and match it with the destination temp descriptor of curr FlatFieldNode */
+ Enumeration ecld = child_hash.keys();
+ while (ecld.hasMoreElements()) {
+ childpp = (PrefetchPair) ecld.nextElement();
+ if (childpp.base == currfsfn.getDst() && (FieldDescriptor)childpp.getDescAt(0)== currfsfn.getField()) {
+ if(childpp.getDesc()!= null && childpp.getisTempDesc()!=null) {
+ if(currfsfn.getSrc().getType().isPtr()) {
+ ArrayList<Descriptor> newdesc = new ArrayList<Descriptor>();
+ ArrayList<Boolean> newbool = new ArrayList<Boolean>();
+ newdesc.addAll(1,childpp.desc);
+ newbool.addAll(1,childpp.isTempDesc);
+ PrefetchPair newpp = new PrefetchPair(currfsfn.getSrc(), newdesc, newbool);
+ Float newprob = child_hash.get(childpp).floatValue();
+ tocompare.put(newpp, newprob);
+ child_hash.remove(childpp);
+ /* Check for independence of prefetch pairs if any in the child prefetch set
+ * to compute new probability */
+ if(child_hash.containsKey(newpp)) {
+ newprob = (float)(1.0 - ((1.0 - child_hash.get(newpp).floatValue()) * (1.0 - tocompare.get(newpp).floatValue())));
+ tocompare.put(newpp, newprob);
+ child_hash.remove(newpp);
+ }
+ }
+ }
+ }
+ }
+
+ /* Merge child prefetch pairs */
+ ecld = child_hash.keys();
+ while(ecld.hasMoreElements()) {
+ childpp = (PrefetchPair) ecld.nextElement();
+ tocompare.put(childpp, child_hash.get(childpp));
+ child_hash.remove(childpp);
+ }
+
+ /* Compare with the orginal prefetch pairs */
+ pSetHasChanged = comparePrefetchSets(prefetch_hash.get(curr), tocompare);
+ /* Enqueue parent nodes */
+ if(pSetHasChanged) {
+ for(int i=0; i<curr.numPrev(); i++) {
+ tovisit.add(curr.getPrev(i));
+ }
+ /* Overwrite the new prefetch set to the global hash table */
+ prefetch_hash.put(curr,tocompare);
+ }
+ }
+
+ /** This function processes the prefetch set of a FlatSeElementNode
+ * It generates a new prefetch set after comparision with its children
+ * It compares the old prefetch set with this new prefetch set and enqueues the parents
+ * of the current node if change occurs and then updates the global flatnode hash table
+ * */
+ private void processFlatSetElementNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
+ boolean pSetHasChanged = false;
+ Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
+ PrefetchPair childpp = null;
+ FlatSetElementNode currfsen = (FlatSetElementNode) curr;
+
+ /* Get each prefetch pair of the child and match it with the destination temp descriptor of curr FlatFieldNode */
+ Enumeration ecld = child_hash.keys();
+ while (ecld.hasMoreElements()) {
+ childpp = (PrefetchPair) ecld.nextElement();
+ //TODO Add comparision for cases like a[i+1]=f.The following only works for cases like a[i]=f
+ if ((childpp.base == currfsen.getDst()) && ((TempDescriptor)childpp.getDescAt(0)== currfsen.getIndex())) {
+ if(childpp.getDesc()!= null && childpp.getisTempDesc()!=null) {
+ if(currfsen.getSrc().getType().isPtr()) {
+ ArrayList<Descriptor> newdesc = new ArrayList<Descriptor>();
+ ArrayList<Boolean> newbool = new ArrayList<Boolean>();
+ newdesc.addAll(1,childpp.desc);
+ newbool.addAll(1,childpp.isTempDesc);
+ PrefetchPair newpp = new PrefetchPair(currfsen.getSrc(), newdesc, newbool);
+ Float newprob = child_hash.get(childpp).floatValue();
+ tocompare.put(newpp, newprob);
+ child_hash.remove(childpp);
+ /* Check for independence of prefetch pairs if any in the child prefetch set
+ * to compute new probability */
+ if(child_hash.containsKey(newpp)) {
+ newprob = (float)(1.0 - ((1.0 - child_hash.get(newpp).floatValue()) * (1.0 - tocompare.get(newpp).floatValue())));
+ tocompare.put(newpp, newprob);
+ child_hash.remove(newpp);
+ }
+ }
+ }
+ }
+ }
+
+ /* Merge child prefetch pairs */
+ ecld = child_hash.keys();
+ while(ecld.hasMoreElements()) {
+ childpp = (PrefetchPair) ecld.nextElement();
+ tocompare.put(childpp, child_hash.get(childpp));
+ child_hash.remove(childpp);
+ }
+
+ /* Compare with the orginal prefetch pairs */
+ pSetHasChanged = comparePrefetchSets(prefetch_hash.get(curr), tocompare);
+ /* Enqueue parent nodes */
+ if(pSetHasChanged) {
+ for(int i=0; i<curr.numPrev(); i++) {
+ tovisit.add(curr.getPrev(i));
+ }
+ /* Overwrite the new prefetch set to the global hash table */
+ prefetch_hash.put(curr,tocompare);
+ }
+ }
+ /** This function applies rules and does analysis for a FlatOpNode
+ * And updates the global prefetch hashtable
+ * */
+ private void processFlatOpNode(FlatNode curr, Hashtable<PrefetchPair, Float> child_hash) {
+ boolean pSetHasChanged = false;
+ int index;
+ Hashtable<PrefetchPair, Float> tocompare = new Hashtable<PrefetchPair, Float>();
+ FlatOpNode currfopn = (FlatOpNode) curr;
+ Enumeration ecld = null;
+ PrefetchPair childpp = null;
+
+ /* Check the Operation type of flatOpNode */
+ if(currfopn.getOp().getOp()== Operation.ASSIGN) {
+ ecld = child_hash.keys();
+ while (ecld.hasMoreElements()) {
+ childpp = (PrefetchPair) ecld.nextElement();
+ ArrayList<Descriptor> copychildpp = (ArrayList<Descriptor>) childpp.desc.clone();
+ ArrayList<Boolean> copybool = (ArrayList<Boolean>) childpp.isTempDesc.clone();
+ /* Base of child prefetch pair same as destination of the current FlatOpNode */
+ if(childpp.base == currfopn.getDest()) {
+ ArrayList<Descriptor> newdesc = new ArrayList<Descriptor>();
+ ArrayList<Boolean> newbool = new ArrayList<Boolean>();
+ newdesc.addAll(childpp.desc);
+ newbool.addAll(childpp.isTempDesc);
+ PrefetchPair newpp = new PrefetchPair(currfopn.getLeft(), newdesc, newbool);
+ Float newprob = child_hash.get(childpp).floatValue();
+ tocompare.put(newpp, newprob);
+ child_hash.remove(childpp);
+ /* Check for independence of prefetch pairs if any in the child prefetch set
+ * to compute new probability */
+ if(child_hash.containsKey(newpp)) {
+ newprob = (float)(1.0 - ((1.0 - child_hash.get(newpp).floatValue()) * (1.0 - tocompare.get(newpp).floatValue())));
+ tocompare.put(newpp, newprob);
+ child_hash.remove(newpp);
+ }
+ /* Any member of the desc of child prefetch pair is same as destination of the current FlatOpNode */
+ } else if(copychildpp.contains(currfopn.getDest())) {
+ index = copychildpp.indexOf((TempDescriptor)currfopn.getDest());
+ copychildpp.set(index, currfopn.getLeft());
+ /* Check if TempDescriptor */
+ if(copybool.get(index).booleanValue() == false){
+ copybool.set(index, true);
+ }
+ ArrayList<Descriptor> newdesc = new ArrayList<Descriptor>();
+ ArrayList<Boolean> newbool = new ArrayList<Boolean>();
+ newdesc.addAll(copychildpp);
+ newbool.addAll(copybool);
+ PrefetchPair newpp = new PrefetchPair(childpp.base, newdesc, newbool);
+ Float newprob = child_hash.get(childpp).floatValue();
+ tocompare.put(newpp, newprob);
+ child_hash.remove(childpp);
+ /* Check for independence of prefetch pairs if any in the child prefetch set
+ * to compute new probability */
+ if(child_hash.containsKey(newpp)) {
+ newprob = (float)(1.0 - ((1.0 - child_hash.get(newpp).floatValue()) * (1.0 - tocompare.get(newpp).floatValue())));
+ tocompare.put(newpp, newprob);
+ child_hash.remove(newpp);
+ }
+
+ }else {
+ continue;
+ }
+ }
+ } else if(currfopn.getRight()!=null) {
+ //FIXME
+ } else {
+ //FIXME
+ }
+
+ /* Merge child prefetch pairs */
+ ecld = child_hash.keys();
+ while(ecld.hasMoreElements()) {
+ childpp = (PrefetchPair) ecld.nextElement();
+ tocompare.put(childpp, child_hash.get(childpp));
+ child_hash.remove(childpp);
+ }
+
+ /* Compare with the orginal prefetch pairs */
+ pSetHasChanged = comparePrefetchSets(prefetch_hash.get(curr), tocompare);
+ /* Enqueue parent nodes */
+ if(pSetHasChanged) {
+ for(int i=0; i<curr.numPrev(); i++) {
+ tovisit.add(curr.getPrev(i));
+ }
+ /* Overwrite the new prefetch set to the global hash table */
+ prefetch_hash.put(curr,tocompare);
+ }
+ }
/** This function prints the Prefetch pairs of a given flatnode */
void printPrefetchPairs(FlatNode fn) {
System.out.print(pp.toString() + ", ");
}
System.out.println(")");
+ } else {
+ System.out.println("Flatnode is currently not present in the global hash: Prefetch Set is Empty");
}
}
projects / IRC.git / commitdiff