From c0d6800748cf296e4d8d3c5a0dc44a0bf06f6c4f Mon Sep 17 00:00:00 2001 From: yeom Date: Fri, 25 Sep 2009 17:08:11 +0000 Subject: [PATCH] move method effects analysis into disjoint analysis. methodeffects object maintains analysis result for each method context. --- Robust/src/Analysis/MLP/AccSet.java | 235 -------------- Robust/src/Analysis/MLP/MLPAnalysis.java | 299 +----------------- .../EffectsKey.java} | 18 +- .../OwnershipAnalysis/EffectsSet.java | 153 +++++++++ .../OwnershipAnalysis/MethodEffects.java | 239 ++++++++++++++ .../OwnershipAnalysis/OwnershipAnalysis.java | 123 ++++++- 6 files changed, 517 insertions(+), 550 deletions(-) delete mode 100644 Robust/src/Analysis/MLP/AccSet.java rename Robust/src/Analysis/{MLP/AccKey.java => OwnershipAnalysis/EffectsKey.java} (63%) create mode 100644 Robust/src/Analysis/OwnershipAnalysis/EffectsSet.java create mode 100644 Robust/src/Analysis/OwnershipAnalysis/MethodEffects.java diff --git a/Robust/src/Analysis/MLP/AccSet.java b/Robust/src/Analysis/MLP/AccSet.java deleted file mode 100644 index 673ff244..00000000 --- a/Robust/src/Analysis/MLP/AccSet.java +++ /dev/null @@ -1,235 +0,0 @@ -package Analysis.MLP; - -import java.util.HashSet; -import java.util.Hashtable; -import java.util.Iterator; - -import IR.Flat.TempDescriptor; - -public class AccSet { - - private Hashtable> readTable; - private Hashtable> writeTable; - - public AccSet() { - - readTable = new Hashtable>(); - writeTable = new Hashtable>(); - - } - - public void addReadingVar(TempDescriptor td, AccKey access) { - HashSet aSet = readTable.get(td); - if (aSet == null) { - aSet = new HashSet(); - } - - aSet.add(access); - readTable.put(td, aSet); - } - - public void addWritingVar(TempDescriptor td, AccKey access) { - - HashSet aSet = writeTable.get(td); - if (aSet == null) { - aSet = new HashSet(); - } - - aSet.add(access); - writeTable.put(td, aSet); - - } - - public boolean containsParam(TempDescriptor td) { - - Iterator iter = readTable.keySet().iterator(); - - while (iter.hasNext()) { - - TempDescriptor key = iter.next(); - if (key.equals(td)) { - return true; - } - - } - - return false; - - } - - public void addParam(TempDescriptor paramTD) { - - if (!readTable.containsKey(paramTD)) { - HashSet readSet = new HashSet(); - readTable.put(paramTD, readSet); - } - - if (!writeTable.containsKey(paramTD)) { - HashSet writeSet = new HashSet(); - writeTable.put(paramTD, writeSet); - } - - } - - public void addAll(AccSet newAccSet) { - - Hashtable> newReadTable = newAccSet - .getReadTable(); - Hashtable> newWriteTable = newAccSet - .getWriteTable(); - - Iterator iter = newReadTable.keySet().iterator(); - while (iter.hasNext()) { // for each variables - TempDescriptor td = iter.next(); - - HashSet currentSet; - if (!readTable.containsKey(td)) { - currentSet = new HashSet(); - } else { - currentSet = readTable.get(td); - } - - HashSet newSet = newReadTable.get(td); - currentSet.addAll(newSet); - readTable.put(td, currentSet); - } - - iter = newWriteTable.keySet().iterator(); - while (iter.hasNext()) { // for each variables - TempDescriptor td = iter.next(); - - HashSet currentSet; - if (!writeTable.containsKey(td)) { - currentSet = new HashSet(); - } else { - currentSet = writeTable.get(td); - } - - HashSet newSet = newWriteTable.get(td); - currentSet.addAll(newSet); - writeTable.put(td, currentSet); - } - - } - - public Hashtable> getReadTable() { - return readTable; - } - - public Hashtable> getWriteTable() { - return writeTable; - } - - public boolean equals(Object o) { - if (o == null) { - return false; - } - - if (!(o instanceof AccSet)) { - return false; - } - - AccSet in = (AccSet) o; - - if (getReadTable().equals(in.getReadTable()) - && getWriteTable().equals(in.getWriteTable())) { - return true; - } else { - return false; - } - - } - - public void printSet() { - - String readStr = ""; - String writeStr = ""; - - readStr = "#Reading#\r\n"; - Iterator iter = getReadTable().keySet().iterator(); - while (iter.hasNext()) { // for each variables - - TempDescriptor td = iter.next(); - HashSet aSet = readTable.get(td); - - readStr += td.getSymbol() + ":" + "{"; - - Iterator setIter = aSet.iterator(); - while (setIter.hasNext()) { - AccKey element = setIter.next(); - readStr += " " + element; - } - readStr += "}\r\n"; - } - - writeStr = "#Writing#\r\n"; - iter = getWriteTable().keySet().iterator(); - while (iter.hasNext()) { // for each variables - - TempDescriptor td = iter.next(); - HashSet aSet = writeTable.get(td); - - writeStr += td.getSymbol() + ":" + "{"; - - Iterator setIter = aSet.iterator(); - while (setIter.hasNext()) { - AccKey element = setIter.next(); - writeStr += " " + element; - } - writeStr += "}\r\n"; - } - - System.out.println(readStr); - System.out.println(writeStr); - - } - - public String toString() { - - String str = "\n"; - - Iterator iter = getReadTable().keySet().iterator(); - while (iter.hasNext()) { // for each variables - - TempDescriptor td = iter.next(); - - str += "\tParameter " + td.getSymbol() + " reading={"; - - HashSet aSet = readTable.get(td); - Iterator setIter = aSet.iterator(); - boolean first = true; - while (setIter.hasNext()) { - AccKey element = setIter.next(); - if (first) { - str += " " + element; - first = false; - } else { - str += " , " + element; - } - - } - str += " }\n"; - - str += "\tParameter " + td.getSymbol() + " writing={"; - - aSet = writeTable.get(td); - setIter = aSet.iterator(); - first = true; - while (setIter.hasNext()) { - AccKey element = setIter.next(); - if (first) { - str += " " + element; - first = false; - } else { - str += " , " + element; - } - - } - str += " }\n"; - - } - - return str; - } - -} diff --git a/Robust/src/Analysis/MLP/MLPAnalysis.java b/Robust/src/Analysis/MLP/MLPAnalysis.java index 4c776dc3..1c9e8eec 100644 --- a/Robust/src/Analysis/MLP/MLPAnalysis.java +++ b/Robust/src/Analysis/MLP/MLPAnalysis.java @@ -46,8 +46,6 @@ public class MLPAnalysis { private Hashtable< FlatNode, VarSrcTokTable > variableResults; private Hashtable< FlatNode, Set > notAvailableResults; private Hashtable< FlatNode, CodePlan > codePlans; - - private Hashtable effectsResults; private Hashtable< FlatEdge, FlatWriteDynamicVarNode > wdvNodesToSpliceIn; @@ -102,8 +100,6 @@ public class MLPAnalysis { notAvailableResults = new Hashtable< FlatNode, Set >(); codePlans = new Hashtable< FlatNode, CodePlan >(); wdvNodesToSpliceIn = new Hashtable< FlatEdge, FlatWriteDynamicVarNode >(); - - effectsResults = new Hashtable(); FlatMethod fmMain = state.getMethodFlat( typeUtil.getMain() ); @@ -187,14 +183,7 @@ public class MLPAnalysis { // point, in a forward fixed-point pass notAvailableForward( fm ); } - - // new pass for method effects analysis - methItr = ownAnalysis.descriptorsToAnalyze.iterator(); - while (methItr.hasNext()) { - Descriptor d = methItr.next(); - FlatMethod fm = state.getMethodFlat(d); - effectsForward(fm); - } + // 7th pass methItr = ownAnalysis.descriptorsToAnalyze.iterator(); @@ -649,292 +638,6 @@ public class MLPAnalysis { } } - private void effectsForward(FlatMethod fm) { - Set flatNodesToVisit = new HashSet(); - flatNodesToVisit.add(fm); - - while (!flatNodesToVisit.isEmpty()) { - FlatNode fn = (FlatNode) flatNodesToVisit.iterator().next(); - flatNodesToVisit.remove(fn); - - AccSet prev = effectsResults.get(fn); - AccSet curr = new AccSet(); - - // merge phase - for (int i = 0; i < fn.numPrev(); i++) { - FlatNode nn = fn.getPrev(i); - AccSet accSet = effectsResults.get(nn); - if (accSet != null) { - curr.addAll(accSet); - } - } - - effects_nodeActions(fn, curr); - - // if a new result, schedule forward nodes for analysis - if (!curr.equals(prev)) { - effectsResults.put(fn, curr); - for (int i = 0; i < fn.numNext(); i++) { - FlatNode nn = fn.getNext(i); - flatNodesToVisit.add(nn); - } - } - } - - } - - - - - private void effects_nodeActions(FlatNode fn, AccSet curr) { - - OwnershipGraph fnOG = ownAnalysis - .getMappingFlatNodeToOwnershipGraph(fn); - - switch (fn.kind()) { - - case FKind.FlatMethod: { - - FlatMethod fm = (FlatMethod) fn; - int numParam = fm.numParameters(); - - for (int i = 0; i < numParam; i++) { - TempDescriptor paramTD = fm.getParameter(i); - - curr.addParam(paramTD); - } - - // for debug - // OwnershipGraph fnOG = - // ownAnalysis.getMappingFlatNodeToOwnershipGraph(fn); - // try { - // fnOG.writeGraph(fn + "FOOGRAPH", true, true, true, true, false); - // } catch (IOException e) { - // System.out.println("Error writing debug capture."); - // System.exit(0); - // } - - } - break; - - case FKind.FlatSetFieldNode: { - - FlatSetFieldNode fsfn = (FlatSetFieldNode) fn; - - TempDescriptor dstDesc = fsfn.getDst(); - FieldDescriptor fieldDesc = fsfn.getField(); - TempDescriptor srcDesc = fsfn.getSrc(); - - LabelNode ln = fnOG.td2ln.get(dstDesc); - if (ln != null) { - Iterator heapRegionsItr = ln - .iteratorToReferencees(); - - String tempStr = ""; - while (heapRegionsItr.hasNext()) { - HeapRegionNode hrn2 = heapRegionsItr.next().getDst(); - - Set paramSet = fnOG.idSecondary2paramIndexSet - .get(hrn2.getID()); - - String param = null; - if (paramSet != null) { - Iterator paramIter = paramSet.iterator(); - param = ""; - while (paramIter.hasNext()) { - param += paramIter.next() + " "; - } - } - tempStr += " " + hrn2 + "(" + param + ")"; - } - - heapRegionsItr = ln.iteratorToReferencees(); - while (heapRegionsItr.hasNext()) { - ReferenceEdge edge = heapRegionsItr.next(); - HeapRegionNode hrn = edge.getDst(); - - if (hrn.isParameter()) { - // currently, handle this case. otherwise, ignore it. - Iterator iter = hrn - .iteratorToReferencers(); - while (iter.hasNext()) { - ReferenceEdge re = iter.next(); - if (re.getSrc() instanceof LabelNode) { - LabelNode labelNode = (LabelNode) re.getSrc(); - - if (curr.containsParam(labelNode - .getTempDescriptor())) { - - curr.addWritingVar(labelNode - .getTempDescriptor(), new AccKey( - fieldDesc.getSymbol(), dstDesc - .getType())); - - } - - } - } - - // check weather this heap region is parameter - // reachable... - - Set paramSet = fnOG.idSecondary2paramIndexSet - .get(hrn.getID()); - if (paramSet != null) { - Iterator paramIter = paramSet.iterator(); - - while (paramIter.hasNext()) { - Integer paramID = paramIter.next(); - - Integer primaryID = fnOG.paramIndex2idPrimary - .get(paramID); - HeapRegionNode paramHRN = fnOG.id2hrn - .get(primaryID); - - HashSet LNSet = getParameterLabelNodeSet( - fnOG, curr, paramHRN); - - Iterator LNSetIter = LNSet - .iterator(); - while (LNSetIter.hasNext()) { - LabelNode labelNode = LNSetIter.next(); - - curr.addWritingVar(labelNode - .getTempDescriptor(), new AccKey( - fieldDesc.getSymbol(), dstDesc - .getType())); - } - - } - } - - } - - } - } - - } - break; - - case FKind.FlatFieldNode: { - - FlatFieldNode ffn = (FlatFieldNode) fn; - - TempDescriptor srcDesc = ffn.getSrc(); - FieldDescriptor fieldDesc = ffn.getField(); - - LabelNode ln = fnOG.td2ln.get(srcDesc); - if (ln != null) { - - Iterator heapRegionsItr = ln - .iteratorToReferencees(); - String tempStr = ""; - while (heapRegionsItr.hasNext()) { - - HeapRegionNode hrn = heapRegionsItr.next().getDst(); - - Set paramSet = fnOG.idSecondary2paramIndexSet - .get(hrn.getID()); - - String param = null; - if (paramSet != null) { - Iterator paramIter = paramSet.iterator(); - param = ""; - while (paramIter.hasNext()) { - param += paramIter.next() + " "; - } - } - tempStr += " " + hrn + "(" + param + ")"; - } - - heapRegionsItr = ln.iteratorToReferencees(); - while (heapRegionsItr.hasNext()) { - ReferenceEdge edge = heapRegionsItr.next(); - HeapRegionNode hrn = edge.getDst(); - - if (hrn.isParameter()) { - Iterator iter = hrn - .iteratorToReferencers(); - - while (iter.hasNext()) { - ReferenceEdge re = iter.next(); - if (re.getSrc() instanceof LabelNode) { - - LabelNode labelNode = (LabelNode) re.getSrc(); - - if (curr.containsParam(labelNode - .getTempDescriptor())) { - curr.addReadingVar(labelNode - .getTempDescriptor(), new AccKey( - fieldDesc.getSymbol(), srcDesc - .getType())); - } - } - } - - // - // check weather this heap region is parameter - // reachable... - // - - Set paramSet = fnOG.idSecondary2paramIndexSet - .get(hrn.getID()); - if (paramSet != null) { - Iterator paramIter = paramSet.iterator(); - - while (paramIter.hasNext()) { - Integer paramID = paramIter.next(); - - Integer primaryID = fnOG.paramIndex2idPrimary - .get(paramID); - HeapRegionNode paramHRN = fnOG.id2hrn - .get(primaryID); - - HashSet LNSet = getParameterLabelNodeSet( - fnOG, curr, paramHRN); - - Iterator LNSetIter = LNSet - .iterator(); - while (LNSetIter.hasNext()) { - LabelNode labelNode = LNSetIter.next(); - - curr.addReadingVar(labelNode - .getTempDescriptor(), new AccKey( - fieldDesc.getSymbol(), srcDesc - .getType())); - } - } - } - } - } - - } - - } - break; - - } - - } - - // returns the set of parameter label node which are associated with the - // specific heap region node. - private HashSet getParameterLabelNodeSet(OwnershipGraph og, - AccSet curr, HeapRegionNode hrn) { - - HashSet set = new HashSet(); - Iterator iter = hrn.iteratorToReferencers(); - while (iter.hasNext()) { - ReferenceEdge re = iter.next(); - if (re.getSrc() instanceof LabelNode) { - LabelNode labelNode = (LabelNode) re.getSrc(); - if (curr.containsParam(labelNode.getTempDescriptor())) { - set.add(labelNode); - } - } - } - return set; - } private void notAvailableForward( FlatMethod fm ) { diff --git a/Robust/src/Analysis/MLP/AccKey.java b/Robust/src/Analysis/OwnershipAnalysis/EffectsKey.java similarity index 63% rename from Robust/src/Analysis/MLP/AccKey.java rename to Robust/src/Analysis/OwnershipAnalysis/EffectsKey.java index 3b02c6f9..b62c6fa8 100644 --- a/Robust/src/Analysis/MLP/AccKey.java +++ b/Robust/src/Analysis/OwnershipAnalysis/EffectsKey.java @@ -1,15 +1,14 @@ -package Analysis.MLP; +package Analysis.OwnershipAnalysis; +import Analysis.MLP.AccKey; import IR.TypeDescriptor; -public class AccKey { +public class EffectsKey { private String fd; private TypeDescriptor td; - // private Integer hrnID; - - public AccKey(String fd, TypeDescriptor td) { + public EffectsKey(String fd, TypeDescriptor td) { this.fd = fd; this.td = td; } @@ -23,7 +22,7 @@ public class AccKey { } public String toString() { - return "(" + td + ")" + fd ; + return "(" + td + ")" + fd; } public int hashCode() { @@ -48,13 +47,14 @@ public class AccKey { return false; } - if (!(o instanceof AccKey)) { + if (!(o instanceof EffectsKey)) { return false; } - AccKey in = (AccKey) o; + EffectsKey in = (EffectsKey) o; - if (fd.equals(in.getFieldDescriptor()) && td.getSymbol().equals(in.getTypeDescriptor().getSymbol())) { + if (fd.equals(in.getFieldDescriptor()) + && td.getSymbol().equals(in.getTypeDescriptor().getSymbol())) { return true; } else { return false; diff --git a/Robust/src/Analysis/OwnershipAnalysis/EffectsSet.java b/Robust/src/Analysis/OwnershipAnalysis/EffectsSet.java new file mode 100644 index 00000000..a7748c19 --- /dev/null +++ b/Robust/src/Analysis/OwnershipAnalysis/EffectsSet.java @@ -0,0 +1,153 @@ +package Analysis.OwnershipAnalysis; + +import java.util.HashSet; +import java.util.Hashtable; +import java.util.Iterator; +import java.util.Set; + +import Analysis.MLP.AccKey; +import Analysis.MLP.AccSet; +import IR.Flat.TempDescriptor; + +public class EffectsSet { + + private Hashtable> readTable; + private Hashtable> writeTable; + + public EffectsSet() { + readTable = new Hashtable>(); + writeTable = new Hashtable>(); + } + + public void addReadingVar(Integer idx, EffectsKey access) { + HashSet aSet = readTable.get(idx); + if (aSet == null) { + aSet = new HashSet(); + } + + aSet.add(access); + readTable.put(idx, aSet); + } + + public void addReadingEffectsSet(Integer idx, HashSet newSet) { + + if (newSet != null) { + HashSet aSet = readTable.get(idx); + if (aSet == null) { + aSet = new HashSet(); + } + aSet.addAll(newSet); + readTable.put(idx, aSet); + } + + } + + public void addWritingEffectsSet(Integer idx, HashSet newSet) { + + if (newSet != null) { + HashSet aSet = writeTable.get(idx); + if (aSet == null) { + aSet = new HashSet(); + } + aSet.addAll(newSet); + writeTable.put(idx, aSet); + } + + } + + public Hashtable> getReadTable() { + return readTable; + } + + public Hashtable> getWriteTable() { + return writeTable; + } + + public void addWritingVar(Integer idx, EffectsKey access) { + HashSet aSet = writeTable.get(idx); + if (aSet == null) { + aSet = new HashSet(); + } + aSet.add(access); + writeTable.put(idx, aSet); + } + + public Set getReadingSet(Integer idx) { + return readTable.get(idx); + } + + public Set getWritingSet(Integer idx) { + return writeTable.get(idx); + } + + public void printSet() { + System.out.println("writeTable=>" + writeTable.hashCode()); + + Set keySet = readTable.keySet(); + Iterator iter = keySet.iterator(); + while (iter.hasNext()) { + Integer idx = iter.next(); + Set effectSet = readTable.get(idx); + String keyStr = "{"; + if (effectSet != null) { + Iterator effectIter = effectSet.iterator(); + while (effectIter.hasNext()) { + EffectsKey key = effectIter.next(); + keyStr += " " + key; + } + } else { + keyStr = "null"; + } + System.out.println("param" + idx + " R=" + keyStr); + } + + keySet = writeTable.keySet(); + System.out.println("# R keyset=" + keySet.size()); + iter = keySet.iterator(); + while (iter.hasNext()) { + Integer idx = iter.next(); + Set effectSet = writeTable.get(idx); + String keyStr = "{"; + if (effectSet != null) { + Iterator effectIter = effectSet.iterator(); + while (effectIter.hasNext()) { + EffectsKey key = effectIter.next(); + keyStr += " " + key; + } + } else { + keyStr = "null"; + } + System.out.println("param" + idx + " W=" + keyStr); + } + + } + + public boolean equals(Object o) { + if (o == null) { + return false; + } + + if (!(o instanceof EffectsSet)) { + return false; + } + + EffectsSet in = (EffectsSet) o; + + if (getReadTable().equals(in.getReadTable()) + && getWriteTable().equals(in.getWriteTable())) { + return true; + } else { + return false; + } + + } + + public int hashCode() { + int hash = 1; + + hash += getReadTable().hashCode() + getWriteTable().hashCode() * 31; + + return hash; + } + +} diff --git a/Robust/src/Analysis/OwnershipAnalysis/MethodEffects.java b/Robust/src/Analysis/OwnershipAnalysis/MethodEffects.java new file mode 100644 index 00000000..49c912f0 --- /dev/null +++ b/Robust/src/Analysis/OwnershipAnalysis/MethodEffects.java @@ -0,0 +1,239 @@ +package Analysis.OwnershipAnalysis; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +import IR.FieldDescriptor; +import IR.Flat.FlatCall; +import IR.Flat.TempDescriptor; + +public class MethodEffects { + + private EffectsSet effectsSet; + + public MethodEffects() { + effectsSet = new EffectsSet(); + } + + public EffectsSet getEffects() { + return effectsSet; + } + + public void analyzeFlatFieldNode(OwnershipGraph og, TempDescriptor srcDesc, + FieldDescriptor fieldDesc) { + + LabelNode ln = getLabelNodeFromTemp(og, srcDesc); + if (ln != null) { + Iterator heapRegionsItr = ln.iteratorToReferencees(); + + while (heapRegionsItr.hasNext()) { + ReferenceEdge edge = heapRegionsItr.next(); + HeapRegionNode hrn = edge.getDst(); + + if (hrn.isParameter()) { + Set paramSet = og.idPrimary2paramIndexSet.get(hrn + .getID()); + + if (paramSet != null) { + Iterator paramIter = paramSet.iterator(); + while (paramIter.hasNext()) { + Integer paramID = paramIter.next(); + effectsSet.addReadingVar(paramID, new EffectsKey( + fieldDesc.getSymbol(), srcDesc.getType())); + + } + } + + // check weather this heap region is parameter + // reachable... + + paramSet = og.idSecondary2paramIndexSet.get(hrn.getID()); + if (paramSet != null) { + Iterator paramIter = paramSet.iterator(); + + while (paramIter.hasNext()) { + Integer paramID = paramIter.next(); + effectsSet.addReadingVar(paramID, new EffectsKey( + fieldDesc.getSymbol(), srcDesc.getType())); + + } + } + + } + } + } + + } + + public void analyzeFlatSetFieldNode(OwnershipGraph og, + TempDescriptor dstDesc, FieldDescriptor fieldDesc) { + + LabelNode ln = getLabelNodeFromTemp(og, dstDesc); + if (ln != null) { + Iterator heapRegionsItr = ln.iteratorToReferencees(); + + while (heapRegionsItr.hasNext()) { + ReferenceEdge edge = heapRegionsItr.next(); + HeapRegionNode hrn = edge.getDst(); + + if (hrn.isParameter()) { + + Set paramSet = og.idPrimary2paramIndexSet.get(hrn + .getID()); + + if (paramSet != null) { + Iterator paramIter = paramSet.iterator(); + while (paramIter.hasNext()) { + Integer paramID = paramIter.next(); + effectsSet.addWritingVar(paramID, new EffectsKey( + fieldDesc.getSymbol(), dstDesc.getType())); + + } + } + + // check weather this heap region is parameter + // reachable... + + paramSet = og.idSecondary2paramIndexSet.get(hrn.getID()); + if (paramSet != null) { + Iterator paramIter = paramSet.iterator(); + + while (paramIter.hasNext()) { + Integer paramID = paramIter.next(); + effectsSet.addWritingVar(paramID, new EffectsKey( + fieldDesc.getSymbol(), dstDesc.getType())); + + } + } + + } + } + } + + } + + private Set getReachableParamIndexSet(OwnershipGraph og, + TempDescriptor paramDesc) { + + HashSet resultSet = new HashSet(); + + LabelNode ln = getLabelNodeFromTemp(og, paramDesc); + if (ln != null) { + + Iterator heapRegionsItr = ln.iteratorToReferencees(); + + while (heapRegionsItr.hasNext()) { + ReferenceEdge edge = heapRegionsItr.next(); + HeapRegionNode hrn = edge.getDst(); + + if (hrn.isParameter()) { + + Set paramSet = og.idPrimary2paramIndexSet.get(hrn + .getID()); + + if (paramSet != null) { + Iterator paramIter = paramSet.iterator(); + while (paramIter.hasNext()) { + Integer paramID = paramIter.next(); + + resultSet.add(paramID); + + } + } + + // check weather this heap region is parameter + // reachable... + + paramSet = og.idSecondary2paramIndexSet.get(hrn.getID()); + if (paramSet != null) { + Iterator paramIter = paramSet.iterator(); + + while (paramIter.hasNext()) { + Integer paramID = paramIter.next(); + + resultSet.add(paramID); + + } + } + + } + } + + } + + return resultSet; + + } + + public void analyzeFlatCall(OwnershipGraph og, FlatCall fc, + MethodContext mc, MethodEffects callee) { + + TempDescriptor[] tdArray = fc.readsTemps(); + + for (int callerIdx = 0; callerIdx < tdArray.length; callerIdx++) { + TempDescriptor paramDesc = tdArray[callerIdx]; + + Set paramIDs = getReachableParamIndexSet(og, paramDesc); + + // handle read effects + Iterator paramIter = paramIDs.iterator(); + while (paramIter.hasNext()) { + Integer paramIdx = paramIter.next(); + HashSet newSet = callee.getEffects().getReadTable() + .get(paramIdx); + effectsSet.addReadingEffectsSet(callerIdx, newSet); + } + + // handle write effects + paramIter = paramIDs.iterator(); + while (paramIter.hasNext()) { + Integer paramIdx = paramIter.next(); + HashSet newSet = callee.getEffects() + .getWriteTable().get(paramIdx); + effectsSet.addWritingEffectsSet(callerIdx, newSet); + } + + } + + } + + protected LabelNode getLabelNodeFromTemp(OwnershipGraph og, + TempDescriptor td) { + assert td != null; + + if (!og.td2ln.containsKey(td)) { + og.td2ln.put(td, new LabelNode(td)); + } + + return og.td2ln.get(td); + } + + public boolean equals(Object o) { + if (o == null) { + return false; + } + + if (!(o instanceof MethodEffects)) { + return false; + } + + MethodEffects in = (MethodEffects) o; + + if (getEffects().equals(in.getEffects())) { + return true; + } else { + return false; + } + + } + + public int hashCode() { + int hash = 1; + + hash += getEffects().hashCode() * 37; + + return hash; + } + +} diff --git a/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java b/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java index 2ca521d0..8ab0ef8c 100644 --- a/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java +++ b/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java @@ -336,7 +336,7 @@ public class OwnershipAnalysis { private boolean writeAllDOTs; //map each FlatNode to its own internal ownership graph - private Hashtable mappingFlatNodeToOwnershipGraph; + private Hashtable mapMethodContextToMethodEffects; @@ -385,7 +385,7 @@ public class OwnershipAnalysis { mapHrnIdToAllocationSite = new Hashtable(); - mappingFlatNodeToOwnershipGraph = new Hashtable(); + mapMethodContextToMethodEffects = new Hashtable(); if( writeAllDOTs ) { @@ -438,6 +438,11 @@ public class OwnershipAnalysis { //System.out.println("Previsiting " + mc); + if(!mapMethodContextToMethodEffects.containsKey(mc)){ + MethodEffects me=new MethodEffects(); + mapMethodContextToMethodEffects.put(mc, me); + } + og = analyzeFlatNode(mc, fm, null, og); setGraphForMethodContext(mc, og); } @@ -457,6 +462,8 @@ public class OwnershipAnalysis { writeFinalContextGraphs(); } + writeMethodEffectsResult(); + if( aliasFile != null ) { if( state.TASK ) { writeAllAliases(aliasFile, treport); @@ -669,6 +676,8 @@ public class OwnershipAnalysis { FlatNode fn, HashSet setRetNodes, OwnershipGraph og) throws java.io.IOException { + + MethodEffects me=mapMethodContextToMethodEffects.get(mc); TempDescriptor lhs; TempDescriptor rhs; @@ -777,6 +786,9 @@ public class OwnershipAnalysis { if( !fld.getType().isImmutable() || fld.getType().isArray() ) { og.assignTempXEqualToTempYFieldF(lhs, rhs, fld); } + + me.analyzeFlatFieldNode(og, rhs, fld); + break; case FKind.FlatSetFieldNode: @@ -787,6 +799,9 @@ public class OwnershipAnalysis { if( !fld.getType().isImmutable() || fld.getType().isArray() ) { og.assignTempXFieldFEqualToTempY(lhs, fld, rhs); } + + me.analyzeFlatSetFieldNode(og, lhs, fld); + break; case FKind.FlatElementNode: @@ -864,6 +879,15 @@ public class OwnershipAnalysis { } else { ogMergeOfAllPossibleCalleeResults.resolveMethodCall(fc, md.isStatic(), flatm, onlyPossibleCallee, mc, null); } + + if(!mapMethodContextToMethodEffects.containsKey(mcNew)){ + MethodEffects meNew=new MethodEffects(); + mapMethodContextToMethodEffects.put(mcNew, meNew); + } + + MethodEffects meFlatCall=mapMethodContextToMethodEffects.get(mcNew); + me.analyzeFlatCall(ogMergeOfAllPossibleCalleeResults,fc,mc,meFlatCall); + } else { // if the method descriptor is virtual, then there could be a @@ -889,7 +913,14 @@ public class OwnershipAnalysis { Set contexts = mapDescriptorToAllMethodContexts.get( md ); assert contexts != null; contexts.add( mcNew ); - + + + if(!mapMethodContextToMethodEffects.containsKey(mcNew)){ + MethodEffects meNew=new MethodEffects(); + mapMethodContextToMethodEffects.put(mcNew, meNew); + } + + addDependent( mc, mcNew ); OwnershipGraph ogPotentialCallee = mapMethodContextToCompleteOwnershipGraph.get( mcNew ); @@ -907,6 +938,9 @@ public class OwnershipAnalysis { ogCopy.resolveMethodCall(fc, possibleMd.isStatic(), pflatm, ogPotentialCallee, mc, null); } + MethodEffects meFlatCall=mapMethodContextToMethodEffects.get(mcNew); + meFlatCall.analyzeFlatCall(ogMergeOfAllPossibleCalleeResults,fc,mcNew,meFlatCall); + ogMergeOfAllPossibleCalleeResults.merge(ogCopy); } } @@ -924,8 +958,8 @@ public class OwnershipAnalysis { break; } - mappingFlatNodeToOwnershipGraph.put(fn, og); - + setMethodEffectsForMethodContext(mc, me); + return og; } @@ -952,6 +986,10 @@ public class OwnershipAnalysis { return fdElement; } + + private void setMethodEffectsForMethodContext(MethodContext mc, MethodEffects me){ + mapMethodContextToMethodEffects.put(mc,me); + } private void setGraphForMethodContext(MethodContext mc, OwnershipGraph og) { @@ -1010,6 +1048,78 @@ public class OwnershipAnalysis { } } + public void writeMethodEffectsResult() throws IOException { + + try { + BufferedWriter bw = new BufferedWriter(new FileWriter( + "MethodEffects_resport.txt")); + + Set mcSet = mapMethodContextToMethodEffects.keySet(); + Iterator mcIter = mcSet.iterator(); + while (mcIter.hasNext()) { + MethodContext mc = mcIter.next(); + MethodDescriptor md = (MethodDescriptor) mc.getDescriptor(); + + MethodEffects me = mapMethodContextToMethodEffects.get(mc); + EffectsSet effectsSet = me.getEffects(); + + bw.write("Method " + mc +"::"+mc.hashCode() + " :\n"); + for (int i = 0; i < md.numParameters(); i++) { + + String paramName = md.getParamName(i); + + Set effectSet = effectsSet + .getReadingSet(i); + String keyStr = "{"; + if (effectSet != null) { + Iterator effectIter = effectSet.iterator(); + while (effectIter.hasNext()) { + EffectsKey key = effectIter.next(); + keyStr += " " + key; + } + } + keyStr += "}"; + bw.write(" Paramter " + paramName + " ReadingSet=" + + keyStr + "\n"); + + effectSet = effectsSet.getWritingSet(new Integer(i)); + keyStr = "{"; + if (effectSet != null) { + Iterator effectIter = effectSet.iterator(); + while (effectIter.hasNext()) { + EffectsKey key = effectIter.next(); + keyStr += " " + key; + } + } + + keyStr += "}"; + bw.write(" Paramter " + paramName + " WritingngSet=" + + keyStr + "\n"); + + } + bw.write("\n"); + + } + + bw.close(); + } catch (IOException e) { + System.err.println(e); + } + + // Set entrySet = mapMethodContextToMethodEffects.entrySet(); + // Iterator itr = entrySet.iterator(); + // while( itr.hasNext() ) { + // Map.Entry me = (Map.Entry) itr.next(); + // MethodContext mc = (MethodContext) me.getKey(); + // MethodEffects og = (MethodEffects) me.getValue(); + // + // try { + // og.writeGraph(mc, true, true, true, false, false); + // } catch( IOException e ) {} + // } + } + + // return just the allocation site associated with one FlatNew node private AllocationSite getAllocationSiteFromFlatNewPRIVATE(FlatNew fn) { @@ -1260,9 +1370,6 @@ public class OwnershipAnalysis { return s; } - public OwnershipGraph getMappingFlatNodeToOwnershipGraph(FlatNode fn) { - return mappingFlatNodeToOwnershipGraph.get(fn); - } -- 2.34.1