From e911e0e8a3aa4694a52a5ceb5300c18db5e88ecb Mon Sep 17 00:00:00 2001 From: yeom Date: Fri, 6 Aug 2010 18:29:53 +0000 Subject: [PATCH] interface to grab the conflict effect set for Stephen, --- .../src/Analysis/OoOJava/ConflictGraph.java | 159 ++-- Robust/src/Analysis/OoOJava/ConflictNode.java | 68 +- .../src/Analysis/OoOJava/OoOJavaAnalysis.java | 736 ++++++++---------- Robust/src/IR/Flat/BuildCode.java | 22 +- 4 files changed, 503 insertions(+), 482 deletions(-) diff --git a/Robust/src/Analysis/OoOJava/ConflictGraph.java b/Robust/src/Analysis/OoOJava/ConflictGraph.java index 2db90da1..8a873f31 100644 --- a/Robust/src/Analysis/OoOJava/ConflictGraph.java +++ b/Robust/src/Analysis/OoOJava/ConflictGraph.java @@ -24,6 +24,7 @@ import IR.Flat.TempDescriptor; public class ConflictGraph { protected Hashtable id2cn; + protected Hashtable>> sese2te; protected DisjointAnalysis da; protected FlatMethod fmEnclosing; @@ -35,6 +36,7 @@ public class ConflictGraph { public ConflictGraph() { id2cn = new Hashtable(); + sese2te = new Hashtable>>(); } public void setDisJointAnalysis(DisjointAnalysis da) { @@ -101,6 +103,7 @@ public class ConflictGraph { } public void addLiveInNodeEffect(Taint t, Effect e) { + FlatSESEEnterNode sese = t.getSESE(); TempDescriptor invar = t.getVar(); AllocSite as = t.getAllocSite(); @@ -111,6 +114,7 @@ public class ConflictGraph { node = new ConflictNode(id, ConflictNode.INVAR, t.getVar(), t.getSESE()); } node.addEffect(as, e); + node.addTaint(t); id2cn.put(id, node); } @@ -184,21 +188,21 @@ public class ConflictGraph { String entryNodeID = entry.getKey(); ConflictNode entryNode = entry.getValue(); - - if(currentNode.isStallSiteNode() && entryNode.isStallSiteNode()){ + + if (currentNode.isStallSiteNode() && entryNode.isStallSiteNode()) { continue; } - - if( (currentNode.isInVarNode() && entryNode.isInVarNode()) && - (currentNode.getSESEIdentifier()==entryNode.getSESEIdentifier()) && - (currentNode.getVar().equals(entryNode.getVar())) ){ + + if ((currentNode.isInVarNode() && entryNode.isInVarNode()) + && (currentNode.getSESEIdentifier() == entryNode.getSESEIdentifier()) + && (currentNode.getVar().equals(entryNode.getVar()))) { continue; } if ((!currentNode.getID().equals(entryNodeID)) && !(analyzedIDSet.contains(currentNode.getID() + entryNodeID) || analyzedIDSet .contains(entryNodeID + currentNode.getID()))) { - + conflictType = calculateConflictType(currentNode, entryNode, useReachInfo); if (conflictType > ConflictGraph.NON_WRITE_CONFLICT) { addConflictEdge(conflictType, currentNode, entryNode); @@ -222,11 +226,11 @@ public class ConflictGraph { Hashtable> alloc2SUEffects = node.getStrongUpdateEffectSet(); conflictType = - updateConflictType(conflictType, determineConflictType(alloc2writeEffects, + updateConflictType(conflictType, determineConflictType(node, alloc2writeEffects, node, alloc2writeEffects, useReachInfo)); conflictType = - updateConflictType(conflictType, hasStrongUpdateConflicts(alloc2SUEffects, + updateConflictType(conflictType, hasStrongUpdateConflicts(node, alloc2SUEffects, node, alloc2readEffects, alloc2writeEffects, useReachInfo)); return conflictType; @@ -245,15 +249,15 @@ public class ConflictGraph { // if node A has write effects on reading/writing regions of node B conflictType = - updateConflictType(conflictType, determineConflictType(alloc2writeEffectsA, + updateConflictType(conflictType, determineConflictType(nodeA, alloc2writeEffectsA, nodeB, alloc2readEffectsB, useReachInfo)); conflictType = - updateConflictType(conflictType, determineConflictType(alloc2writeEffectsA, + updateConflictType(conflictType, determineConflictType(nodeA, alloc2writeEffectsA, nodeB, alloc2writeEffectsB, useReachInfo)); // if node B has write effects on reading regions of node A conflictType = - updateConflictType(conflictType, determineConflictType(alloc2writeEffectsB, + updateConflictType(conflictType, determineConflictType(nodeB, alloc2writeEffectsB, nodeA, alloc2readEffectsA, useReachInfo)); // strong udpate effects conflict with all effects @@ -261,21 +265,22 @@ public class ConflictGraph { // if node A has SU on regions of node B if (!alloc2SUEffectsA.isEmpty()) { conflictType = - updateConflictType(conflictType, hasStrongUpdateConflicts(alloc2SUEffectsA, + updateConflictType(conflictType, hasStrongUpdateConflicts(nodeA, alloc2SUEffectsA, nodeB, alloc2readEffectsB, alloc2writeEffectsB, useReachInfo)); } // if node B has SU on regions of node A if (!alloc2SUEffectsB.isEmpty()) { conflictType = - updateConflictType(conflictType, hasStrongUpdateConflicts(alloc2SUEffectsB, + updateConflictType(conflictType, hasStrongUpdateConflicts(nodeB, alloc2SUEffectsB, nodeA, alloc2readEffectsA, alloc2writeEffectsA, useReachInfo)); } return conflictType; } - private int hasStrongUpdateConflicts(Hashtable> SUEffectsTableA, + private int hasStrongUpdateConflicts(ConflictNode nodeA, + Hashtable> SUEffectsTableA, ConflictNode nodeB, Hashtable> readTableB, Hashtable> writeTableB, boolean useReachInfo) { @@ -305,6 +310,10 @@ public class ConflictGraph { FlatNew fnRoot2 = asB.getFlatNew(); FlatNew fnTarget = strongUpdateA.getAffectedAllocSite().getFlatNew(); if (da.mayBothReachTarget(fmEnclosing, fnRoot1, fnRoot2, fnTarget)) { + addCoarseEffect(nodeA, asA, strongUpdateA); + if (!nodeA.equals(nodeB)) { + addCoarseEffect(nodeB, asB, effectB); + } conflictType = updateConflictType(conflictType, ConflictGraph.COARSE_GRAIN_EDGE); } } else { @@ -336,9 +345,13 @@ public class ConflictGraph { FlatNew fnRoot2 = asB.getFlatNew(); FlatNew fnTarget = strongUpdateA.getAffectedAllocSite().getFlatNew(); if (da.mayBothReachTarget(fmEnclosing, fnRoot1, fnRoot2, fnTarget)) { + addCoarseEffect(nodeA, asA, strongUpdateA); + if (!nodeA.equals(nodeB)) { + addCoarseEffect(nodeB, asB, effectB); + } conflictType = updateConflictType(conflictType, ConflictGraph.COARSE_GRAIN_EDGE); } - }else{ + } else { return ConflictGraph.CONFLICT; } } @@ -353,7 +366,8 @@ public class ConflictGraph { } - private int determineConflictType(Hashtable> nodeAtable, + private int determineConflictType(ConflictNode nodeA, + Hashtable> nodeAtable, ConflictNode nodeB, Hashtable> nodeBtable, boolean useReachInfo) { int conflictType = ConflictGraph.NON_WRITE_CONFLICT; @@ -385,16 +399,24 @@ public class ConflictGraph { if (fnRoot1.equals(fnRoot2)) { if (!da.mayManyReachTarget(fmEnclosing, fnRoot1, fnTarget)) { // fine-grained conflict case - conflictType = - updateConflictType(conflictType, ConflictGraph.FINE_GRAIN_EDGE); + conflictType = updateConflictType(conflictType, ConflictGraph.FINE_GRAIN_EDGE); } else { + // coarse-grained conflict case + addCoarseEffect(nodeA, asA, effectA); + if (!nodeA.equals(nodeB)) { + addCoarseEffect(nodeB, asB, effectB); + } conflictType = - updateConflictType(conflictType, ConflictGraph.COARSE_GRAIN_EDGE); + updateConflictType(conflictType, ConflictGraph.COARSE_GRAIN_EDGE); } } else { if (da.mayBothReachTarget(fmEnclosing, fnRoot1, fnRoot2, fnTarget)) { + addCoarseEffect(nodeA, asA, effectA); + if (!nodeA.equals(nodeB)) { + addCoarseEffect(nodeB, asB, effectB); + } conflictType = - updateConflictType(conflictType, ConflictGraph.COARSE_GRAIN_EDGE); + updateConflictType(conflictType, ConflictGraph.COARSE_GRAIN_EDGE); } else { } } @@ -410,6 +432,29 @@ public class ConflictGraph { return conflictType; } + private void addCoarseEffect(ConflictNode node, AllocSite as, Effect e) { + Taint t = node.getTaint(as); + addEffectSetByTaint(t, e); + } + + private void addEffectSetByTaint(Taint t, Effect e) { + + Hashtable> taint2Conflicts = sese2te.get(t.getSESE()); + if (taint2Conflicts == null) { + taint2Conflicts = new Hashtable>(); + } + + Set effectSet = taint2Conflicts.get(t); + if (effectSet == null) { + effectSet = new HashSet(); + } + effectSet.add(e); + taint2Conflicts.put(t, effectSet); + + sese2te.put(t.getSESE(), taint2Conflicts); + + } + private int updateConflictType(int current, int newType) { if (newType > current) { return newType; @@ -461,9 +506,8 @@ public class ConflictGraph { } } - public SESEWaitingQueue getWaitingElementSetBySESEID(int seseID, - Set seseLockSet) { - + public SESEWaitingQueue getWaitingElementSetBySESEID(int seseID, Set seseLockSet) { + HashSet waitingElementSet = new HashSet(); Iterator iter = id2cn.entrySet().iterator(); @@ -506,56 +550,52 @@ public class ConflictGraph { // handle the case that multiple enqueues by an SESE for different live-in // into the same queue return refineQueue(waitingElementSet); -// return waitingElementSet; + // return waitingElementSet; } - + public SESEWaitingQueue refineQueue(Set waitingElementSet) { - Set refinedSet=new HashSet(); + Set refinedSet = new HashSet(); HashMap> map = new HashMap>(); - SESEWaitingQueue seseDS=new SESEWaitingQueue(); + SESEWaitingQueue seseDS = new SESEWaitingQueue(); - for (Iterator iterator = waitingElementSet.iterator(); iterator - .hasNext();) { + for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) { WaitingElement waitingElement = (WaitingElement) iterator.next(); - Set set=map.get(new Integer(waitingElement.getQueueID())); - if(set==null){ - set=new HashSet(); + Set set = map.get(new Integer(waitingElement.getQueueID())); + if (set == null) { + set = new HashSet(); } set.add(waitingElement); map.put(new Integer(waitingElement.getQueueID()), set); } - - Set keySet=map.keySet(); + + Set keySet = map.keySet(); for (Iterator iterator = keySet.iterator(); iterator.hasNext();) { Integer queueID = (Integer) iterator.next(); - Set queueWEset=map.get(queueID); - refineQueue(queueID.intValue(),queueWEset,seseDS); + Set queueWEset = map.get(queueID); + refineQueue(queueID.intValue(), queueWEset, seseDS); } - + return seseDS; } - - - private void refineQueue(int queueID, - Set waitingElementSet, SESEWaitingQueue seseDS) { + + private void refineQueue(int queueID, Set waitingElementSet, + SESEWaitingQueue seseDS) { if (waitingElementSet.size() > 1) { - //only consider there is more than one element submitted by same SESE + // only consider there is more than one element submitted by same SESE Set refinedSet = new HashSet(); int numCoarse = 0; int numRead = 0; int numWrite = 0; - int total=waitingElementSet.size(); + int total = waitingElementSet.size(); WaitingElement SCCelement = null; WaitingElement coarseElement = null; - for (Iterator iterator = waitingElementSet.iterator(); iterator - .hasNext();) { - WaitingElement waitingElement = (WaitingElement) iterator - .next(); + for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) { + WaitingElement waitingElement = (WaitingElement) iterator.next(); if (waitingElement.getStatus() == ConflictNode.FINE_READ) { numRead++; } else if (waitingElement.getStatus() == ConflictNode.FINE_WRITE) { @@ -565,7 +605,7 @@ public class ConflictGraph { coarseElement = waitingElement; } else if (waitingElement.getStatus() == ConflictNode.SCC) { SCCelement = waitingElement; - } + } } if (SCCelement != null) { @@ -581,11 +621,12 @@ public class ConflictGraph { } else if (numCoarse == total) { // if there are multiple coarses, enqueue just one coarse. refinedSet.add(coarseElement); - } else if(numWrite==total || (numRead+numWrite)==total){ - // code generator is going to handle the case for multiple writes & read/writes. + } else if (numWrite == total || (numRead + numWrite) == total) { + // code generator is going to handle the case for multiple writes & + // read/writes. seseDS.setType(queueID, SESEWaitingQueue.EXCEPTION); refinedSet.addAll(waitingElementSet); - } else{ + } else { // otherwise, enqueue everything. refinedSet.addAll(waitingElementSet); } @@ -593,9 +634,9 @@ public class ConflictGraph { } else { seseDS.setWaitingElementSet(queueID, waitingElementSet); } - + } - + public Set getStallSiteWaitingElementSet(FlatNode stallSite, Set seseLockSet) { @@ -634,6 +675,10 @@ public class ConflictGraph { return waitingElementSet; } + public Hashtable> getConflictEffectSet(FlatSESEEnterNode fsen) { + return sese2te.get(fsen); + } + public void writeGraph(String graphName, boolean filter) throws java.io.IOException { graphName = graphName.replaceAll("[\\W]", ""); @@ -657,11 +702,11 @@ public class ConflictGraph { continue; } - - if(node.getEdgeSet().isEmpty()){ + + if (node.getEdgeSet().isEmpty()) { continue; } - + } String attributes = "["; diff --git a/Robust/src/Analysis/OoOJava/ConflictNode.java b/Robust/src/Analysis/OoOJava/ConflictNode.java index 69338635..c0f14a83 100644 --- a/Robust/src/Analysis/OoOJava/ConflictNode.java +++ b/Robust/src/Analysis/OoOJava/ConflictNode.java @@ -7,6 +7,7 @@ import java.util.Set; import Analysis.Disjoint.AllocSite; import Analysis.Disjoint.Effect; +import Analysis.Disjoint.Taint; import IR.Flat.FlatNew; import IR.Flat.FlatNode; import IR.Flat.FlatSESEEnterNode; @@ -16,6 +17,7 @@ public class ConflictNode { protected HashSet edgeSet; protected HashSet allocSet; + protected HashSet taintSet; protected Hashtable> alloc2readEffectSet; protected Hashtable> alloc2writeEffectSet; @@ -37,23 +39,23 @@ public class ConflictNode { public static final int INVAR = 0; public static final int STALLSITE = 1; - - public ConflictNode(String id, int nodeType, TempDescriptor var, FlatNode stallSite){ + + public ConflictNode(String id, int nodeType, TempDescriptor var, FlatNode stallSite) { this(id, var, nodeType); - this.stallSite=stallSite; + this.stallSite = stallSite; } - - public ConflictNode(String id, int nodeType, TempDescriptor var, FlatSESEEnterNode fsen){ + + public ConflictNode(String id, int nodeType, TempDescriptor var, FlatSESEEnterNode fsen) { this(id, var, nodeType); - this.fsen=fsen; + this.fsen = fsen; } - public ConflictNode(String id, TempDescriptor var, int nodeType) { edgeSet = new HashSet(); - // redundant views of access root's + // redundant views of access root's // allocation sites for efficient retrieval allocSet = new HashSet(); + taintSet = new HashSet(); alloc2readEffectSet = new Hashtable>(); alloc2writeEffectSet = new Hashtable>(); @@ -61,7 +63,21 @@ public class ConflictNode { this.id = id; this.nodeType = nodeType; - this.var=var; + this.var = var; + } + + public void addTaint(Taint t) { + taintSet.add(t); + } + + public Taint getTaint(AllocSite as) { + for (Iterator iterator = taintSet.iterator(); iterator.hasNext();) { + Taint t = (Taint) iterator.next(); + if (t.getAllocSite().equals(as)) { + return t; + } + } + return null; } public void addEffect(AllocSite as, Effect e) { @@ -75,7 +91,7 @@ public class ConflictNode { } public void addReadEffect(AllocSite as, Effect e) { - allocSet.add(as); + allocSet.add(as); Set effectSet = alloc2readEffectSet.get(as); if (effectSet == null) { effectSet = new HashSet(); @@ -86,7 +102,7 @@ public class ConflictNode { } public void addWriteEffect(AllocSite as, Effect e) { - allocSet.add(as); + allocSet.add(as); Set effectSet = alloc2writeEffectSet.get(as); if (effectSet == null) { effectSet = new HashSet(); @@ -97,7 +113,7 @@ public class ConflictNode { } public void addStrongUpdateEffect(AllocSite as, Effect e) { - allocSet.add(as); + allocSet.add(as); Set effectSet = alloc2strongUpdateEffectSet.get(as); if (effectSet == null) { effectSet = new HashSet(); @@ -129,18 +145,18 @@ public class ConflictNode { public boolean isStallSiteNode() { return !isInVarNode(); } - - public Set getFlatNewSet(){ - Set fnSet=new HashSet(); + + public Set getFlatNewSet() { + Set fnSet = new HashSet(); for (Iterator iterator = allocSet.iterator(); iterator.hasNext();) { AllocSite as = (AllocSite) iterator.next(); - FlatNew fn=as.getFlatNew(); + FlatNew fn = as.getFlatNew(); fnSet.add(fn); } return fnSet; } - - public TempDescriptor getVar(){ + + public TempDescriptor getVar() { return var; } @@ -155,15 +171,15 @@ public class ConflictNode { public String getID() { return id; } - - public FlatNode getStallSiteFlatNode(){ + + public FlatNode getStallSiteFlatNode() { return stallSite; } - - public int getSESEIdentifier(){ + + public int getSESEIdentifier() { return fsen.getIdentifier(); } - + public boolean equals(Object o) { if (o == null) { @@ -202,9 +218,9 @@ public class ConflictNode { return str; } - - public String toString(){ + + public String toString() { return id; } - + } diff --git a/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java b/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java index aa0db186..a6065eab 100644 --- a/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java +++ b/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java @@ -66,8 +66,8 @@ public class OoOJavaAnalysis { private Hashtable wdvNodesToSpliceIn; - // temporal data structures to track analysis progress. - static private int uniqueLockSetId = 0; + // temporal data structures to track analysis progress. + static private int uniqueLockSetId = 0; // mapping of a conflict graph to its compiled lock private Hashtable> conflictGraph2SESELock; // mapping of a sese block to its conflict graph @@ -116,12 +116,10 @@ public class OoOJavaAnalysis { descriptorsToAnalyze.add(mdSourceEntry); - // 1st pass, find basic rblock relations & status rblockRel = new RBlockRelationAnalysis(state, typeUtil, callGraph); rblockStatus = new RBlockStatusAnalysis(state, typeUtil, callGraph, rblockRel); - // 2nd pass, liveness, in-set out-set (no virtual reads yet!) Iterator rootItr = rblockRel.getRootSESEs().iterator(); while (rootItr.hasNext()) { @@ -150,17 +148,14 @@ public class OoOJavaAnalysis { // 5th pass, use disjointness with NO FLAGGED REGIONS // to compute taints and effects - disjointAnalysisTaints = - new DisjointAnalysis(state, - typeUtil, - callGraph, - liveness, - arrayReferencees, - null, // no FlatNew set to flag - rblockRel, - rblockStatus - ); - + disjointAnalysisTaints = + new DisjointAnalysis(state, typeUtil, callGraph, liveness, arrayReferencees, null, // no + // FlatNew + // set + // to + // flag + rblockRel, rblockStatus); + // 6th pass, not available analysis FOR VARIABLES! methItr = descriptorsToAnalyze.iterator(); while (methItr.hasNext()) { @@ -171,104 +166,97 @@ public class OoOJavaAnalysis { // point, in a forward fixed-point pass notAvailableForward(fm); } - - // 7th pass, make conflict graph + + // 7th pass, make conflict graph // conflict graph is maintained by each parent sese, - Iterator descItr=disjointAnalysisTaints.getDescriptorsToAnalyze().iterator(); + Iterator descItr = disjointAnalysisTaints.getDescriptorsToAnalyze().iterator(); while (descItr.hasNext()) { - Descriptor d = (Descriptor)descItr.next(); + Descriptor d = (Descriptor) descItr.next(); FlatMethod fm = state.getMethodFlat(d); - if(fm != null) + if (fm != null) makeConflictGraph(fm); } - // debug routine + // debug routine /* - Iterator iter = sese2conflictGraph.entrySet().iterator(); - while (iter.hasNext()) { - Entry e = (Entry) iter.next(); - FlatNode fn = (FlatNode) e.getKey(); - ConflictGraph conflictGraph = (ConflictGraph) e.getValue(); - System.out.println("---------------------------------------"); - System.out.println("CONFLICT GRAPH for " + fn); - Set keySet = conflictGraph.id2cn.keySet(); - for (Iterator iterator = keySet.iterator(); iterator.hasNext();) { - String key = (String) iterator.next(); - ConflictNode node = conflictGraph.id2cn.get(key); - System.out.println("key=" + key + " \n" + node.toStringAllEffects()); - } - } - */ - - // 8th pass, calculate all possible conflicts without using reachability info - // and identify set of FlatNew that next disjoint reach. analysis should flag + * Iterator iter = sese2conflictGraph.entrySet().iterator(); while + * (iter.hasNext()) { Entry e = (Entry) iter.next(); FlatNode fn = + * (FlatNode) e.getKey(); ConflictGraph conflictGraph = (ConflictGraph) + * e.getValue(); + * System.out.println("---------------------------------------"); + * System.out.println("CONFLICT GRAPH for " + fn); Set keySet = + * conflictGraph.id2cn.keySet(); for (Iterator iterator = keySet.iterator(); + * iterator.hasNext();) { String key = (String) iterator.next(); + * ConflictNode node = conflictGraph.id2cn.get(key); + * System.out.println("key=" + key + " \n" + node.toStringAllEffects()); } } + */ + + // 8th pass, calculate all possible conflicts without using reachability + // info + // and identify set of FlatNew that next disjoint reach. analysis should + // flag Set sitesToFlag = new HashSet(); - calculateConflicts(sitesToFlag,false); - + calculateConflicts(sitesToFlag, false); + // 9th pass, ask disjoint analysis to compute reachability // for objects that may cause heap conflicts so the most // efficient method to deal with conflict can be computed // later - - disjointAnalysisReach = - new DisjointAnalysis(state, - typeUtil, - callGraph, - liveness, - arrayReferencees, - sitesToFlag, - null, // don't do effects analysis again! - null // don't do effects analysis again! - ); + + disjointAnalysisReach = + new DisjointAnalysis(state, typeUtil, callGraph, liveness, arrayReferencees, sitesToFlag, + null, // don't do effects analysis again! + null // don't do effects analysis again! + ); // 10th pass, calculate conflicts with reachability info - calculateConflicts(null, true); - + calculateConflicts(null, true); + // 11th pass, compiling locks synthesizeLocks(); - + // 12th pass, compute a plan for code injections - methItr =descriptorsToAnalyze.iterator(); - while( methItr.hasNext() ) { - Descriptor d = methItr.next(); - FlatMethod fm = state.getMethodFlat( d ); - codePlansForward( fm ); + methItr = descriptorsToAnalyze.iterator(); + while (methItr.hasNext()) { + Descriptor d = methItr.next(); + FlatMethod fm = state.getMethodFlat(d); + codePlansForward(fm); } - + // 13th pass, // splice new IR nodes into graph after all // analysis passes are complete Iterator spliceItr = wdvNodesToSpliceIn.entrySet().iterator(); - while( spliceItr.hasNext() ) { - Map.Entry me = (Map.Entry) spliceItr.next(); + while (spliceItr.hasNext()) { + Map.Entry me = (Map.Entry) spliceItr.next(); FlatWriteDynamicVarNode fwdvn = (FlatWriteDynamicVarNode) me.getValue(); fwdvn.spliceIntoIR(); } - - - if( state.OOODEBUG ) { + + if (state.OOODEBUG) { try { - writeReports( "" ); - disjointAnalysisTaints.getEffectsAnalysis().writeEffects( "effects.txt" ); + writeReports(""); + disjointAnalysisTaints.getEffectsAnalysis().writeEffects("effects.txt"); writeConflictGraph(); - } catch( IOException e ) {} + } catch (IOException e) { + } } - + } - - private void writeFile(Set sitesToFlag){ - - try{ - BufferedWriter bw = new BufferedWriter( new FileWriter( "sitesToFlag.txt" ) ); - - for (Iterator iterator = sitesToFlag.iterator(); iterator.hasNext();) { - FlatNew fn = (FlatNew) iterator.next(); - bw.write( fn+"\n" ); - } - bw.close(); - }catch(IOException e){ - + + private void writeFile(Set sitesToFlag) { + + try { + BufferedWriter bw = new BufferedWriter(new FileWriter("sitesToFlag.txt")); + + for (Iterator iterator = sitesToFlag.iterator(); iterator.hasNext();) { + FlatNew fn = (FlatNew) iterator.next(); + bw.write(fn + "\n"); + } + bw.close(); + } catch (IOException e) { + } - + } private void livenessAnalysisBackward(FlatSESEEnterNode fsen, boolean toplevel, @@ -286,7 +274,8 @@ public class OoOJavaAnalysis { flatNodesToVisit.add(fsen.getFlatExit()); } - Hashtable> livenessResults = new Hashtable>(); + Hashtable> livenessResults = + new Hashtable>(); if (toplevel) { liveout = new Hashtable>(); @@ -458,8 +447,8 @@ public class OoOJavaAnalysis { // anything virtually read by this SESE should be pruned // of parent or sibling sources Set liveVars = livenessRootView.get(fn); - Set fsenVirtReads = vstTable.calcVirtReadsAndPruneParentAndSiblingTokens( - fsen, liveVars); + Set fsenVirtReads = + vstTable.calcVirtReadsAndPruneParentAndSiblingTokens(fsen, liveVars); Set fsenVirtReadsOld = livenessVirtualReads.get(fn); if (fsenVirtReadsOld != null) { fsenVirtReads.addAll(fsenVirtReadsOld); @@ -677,8 +666,8 @@ public class OoOJavaAnalysis { VariableSourceToken vst = vstIfStatic.vst; - Iterator availItr = vstTable.get(vst.getSESE(), vst.getAge()) - .iterator(); + Iterator availItr = + vstTable.get(vst.getSESE(), vst.getAge()).iterator(); // look through things that are also available from same source while (availItr.hasNext()) { @@ -691,8 +680,8 @@ public class OoOJavaAnalysis { // if a variable is available from the same source, AND it ALSO // only comes from one statically known source, mark it available VSTWrapper vstIfStaticNotUsed = new VSTWrapper(); - Integer srcTypeAlso = vstTable.getRefVarSrcType(refVarAlso, currentSESE, - vstIfStaticNotUsed); + Integer srcTypeAlso = + vstTable.getRefVarSrcType(refVarAlso, currentSESE, vstIfStaticNotUsed); if (srcTypeAlso.equals(VarSrcTokTable.SrcType_STATIC)) { notAvailSet.remove(refVarAlso); } @@ -706,85 +695,76 @@ public class OoOJavaAnalysis { } // end switch } - -private void codePlansForward( FlatMethod fm ) { - + private void codePlansForward(FlatMethod fm) { + // start from flat method top, visit every node in // method exactly once Set flatNodesToVisit = new HashSet(); - flatNodesToVisit.add( fm ); + flatNodesToVisit.add(fm); - Set visited = new HashSet(); + Set visited = new HashSet(); - while( !flatNodesToVisit.isEmpty() ) { + while (!flatNodesToVisit.isEmpty()) { Iterator fnItr = flatNodesToVisit.iterator(); FlatNode fn = fnItr.next(); - flatNodesToVisit.remove( fn ); - visited.add( fn ); + flatNodesToVisit.remove(fn); + visited.add(fn); Stack seseStack = rblockRel.getRBlockStacks(fm, fn); - assert seseStack != null; + assert seseStack != null; // use incoming results as "dot statement" or just // before the current statement VarSrcTokTable dotSTtable = new VarSrcTokTable(); - for( int i = 0; i < fn.numPrev(); i++ ) { - FlatNode nn = fn.getPrev( i ); - dotSTtable.merge( variableResults.get( nn ) ); + for (int i = 0; i < fn.numPrev(); i++) { + FlatNode nn = fn.getPrev(i); + dotSTtable.merge(variableResults.get(nn)); } // find dt-st notAvailableSet also - Set dotSTnotAvailSet = new HashSet(); - for( int i = 0; i < fn.numPrev(); i++ ) { - FlatNode nn = fn.getPrev( i ); - Set notAvailIn = notAvailableResults.get( nn ); - if( notAvailIn != null ) { - dotSTnotAvailSet.addAll( notAvailIn ); + Set dotSTnotAvailSet = new HashSet(); + for (int i = 0; i < fn.numPrev(); i++) { + FlatNode nn = fn.getPrev(i); + Set notAvailIn = notAvailableResults.get(nn); + if (notAvailIn != null) { + dotSTnotAvailSet.addAll(notAvailIn); } } - Set dotSTlive = livenessRootView.get( fn ); + Set dotSTlive = livenessRootView.get(fn); - if( !seseStack.empty() ) { - codePlans_nodeActions( fn, - dotSTlive, - dotSTtable, - dotSTnotAvailSet, - seseStack.peek() - ); + if (!seseStack.empty()) { + codePlans_nodeActions(fn, dotSTlive, dotSTtable, dotSTnotAvailSet, seseStack.peek()); } - for( int i = 0; i < fn.numNext(); i++ ) { - FlatNode nn = fn.getNext( i ); + for (int i = 0; i < fn.numNext(); i++) { + FlatNode nn = fn.getNext(i); - if( !visited.contains( nn ) ) { - flatNodesToVisit.add( nn ); - } + if (!visited.contains(nn)) { + flatNodesToVisit.add(nn); + } } } } - private void codePlans_nodeActions( FlatNode fn, - Set liveSetIn, - VarSrcTokTable vstTableIn, - Set notAvailSetIn, - FlatSESEEnterNode currentSESE ) { - - CodePlan plan = new CodePlan( currentSESE); + private void codePlans_nodeActions(FlatNode fn, Set liveSetIn, + VarSrcTokTable vstTableIn, Set notAvailSetIn, FlatSESEEnterNode currentSESE) { + + CodePlan plan = new CodePlan(currentSESE); - switch( fn.kind() ) { + switch (fn.kind()) { case FKind.FlatSESEEnterNode: { FlatSESEEnterNode fsen = (FlatSESEEnterNode) fn; - assert fsen.equals( currentSESE ); + assert fsen.equals(currentSESE); // track the source types of the in-var set so generated // code at this SESE issue can compute the number of // dependencies properly Iterator inVarItr = fsen.getInVarSet().iterator(); - while( inVarItr.hasNext() ) { - TempDescriptor inVar = inVarItr.next(); + while (inVarItr.hasNext()) { + TempDescriptor inVar = inVarItr.next(); // when we get to an SESE enter node we change the // currentSESE variable of this analysis to the @@ -793,158 +773,141 @@ private void codePlansForward( FlatMethod fm ) { // the parent SESE in--at other FlatNode types just // use the currentSESE VSTWrapper vstIfStatic = new VSTWrapper(); - Integer srcType = - vstTableIn.getRefVarSrcType( inVar, - fsen.getParent(), - vstIfStatic - ); - - // the current SESE needs a local space to track the dynamic - // variable and the child needs space in its SESE record - if( srcType.equals( VarSrcTokTable.SrcType_DYNAMIC ) ) { - fsen.addDynamicInVar( inVar ); - fsen.getParent().addDynamicVar( inVar ); - - } else if( srcType.equals( VarSrcTokTable.SrcType_STATIC ) ) { - fsen.addStaticInVar( inVar ); - VariableSourceToken vst = vstIfStatic.vst; - fsen.putStaticInVar2src( inVar, vst ); - fsen.addStaticInVarSrc( new SESEandAgePair( vst.getSESE(), - vst.getAge() - ) - ); - } else { - assert srcType.equals( VarSrcTokTable.SrcType_READY ); - fsen.addReadyInVar( inVar ); - } + Integer srcType = vstTableIn.getRefVarSrcType(inVar, fsen.getParent(), vstIfStatic); + + // the current SESE needs a local space to track the dynamic + // variable and the child needs space in its SESE record + if (srcType.equals(VarSrcTokTable.SrcType_DYNAMIC)) { + fsen.addDynamicInVar(inVar); + fsen.getParent().addDynamicVar(inVar); + + } else if (srcType.equals(VarSrcTokTable.SrcType_STATIC)) { + fsen.addStaticInVar(inVar); + VariableSourceToken vst = vstIfStatic.vst; + fsen.putStaticInVar2src(inVar, vst); + fsen.addStaticInVarSrc(new SESEandAgePair(vst.getSESE(), vst.getAge())); + } else { + assert srcType.equals(VarSrcTokTable.SrcType_READY); + fsen.addReadyInVar(inVar); + } } - } break; + } + break; case FKind.FlatSESEExitNode: { FlatSESEExitNode fsexn = (FlatSESEExitNode) fn; - } break; + } + break; case FKind.FlatOpNode: { FlatOpNode fon = (FlatOpNode) fn; - if( fon.getOp().getOp() == Operation.ASSIGN ) { - TempDescriptor lhs = fon.getDest(); - TempDescriptor rhs = fon.getLeft(); + if (fon.getOp().getOp() == Operation.ASSIGN) { + TempDescriptor lhs = fon.getDest(); + TempDescriptor rhs = fon.getLeft(); - // if this is an op node, don't stall, copy - // source and delay until we need to use value + // if this is an op node, don't stall, copy + // source and delay until we need to use value - // ask whether lhs and rhs sources are dynamic, static, etc. + // ask whether lhs and rhs sources are dynamic, static, etc. VSTWrapper vstIfStatic = new VSTWrapper(); - Integer lhsSrcType - = vstTableIn.getRefVarSrcType( lhs, - currentSESE, - vstIfStatic - ); - Integer rhsSrcType - = vstTableIn.getRefVarSrcType( rhs, - currentSESE, - vstIfStatic - ); - - if( rhsSrcType.equals( VarSrcTokTable.SrcType_DYNAMIC ) ) { - // if rhs is dynamic going in, lhs will definitely be dynamic - // going out of this node, so track that here - plan.addDynAssign( lhs, rhs ); - currentSESE.addDynamicVar( lhs ); - currentSESE.addDynamicVar( rhs ); - - } else if( lhsSrcType.equals( VarSrcTokTable.SrcType_DYNAMIC ) ) { - // otherwise, if the lhs is dynamic, but the rhs is not, we - // need to update the variable's dynamic source as "current SESE" - plan.addDynAssign( lhs ); - } - - // only break if this is an ASSIGN op node, - // otherwise fall through to default case - break; + Integer lhsSrcType = vstTableIn.getRefVarSrcType(lhs, currentSESE, vstIfStatic); + Integer rhsSrcType = vstTableIn.getRefVarSrcType(rhs, currentSESE, vstIfStatic); + + if (rhsSrcType.equals(VarSrcTokTable.SrcType_DYNAMIC)) { + // if rhs is dynamic going in, lhs will definitely be dynamic + // going out of this node, so track that here + plan.addDynAssign(lhs, rhs); + currentSESE.addDynamicVar(lhs); + currentSESE.addDynamicVar(rhs); + + } else if (lhsSrcType.equals(VarSrcTokTable.SrcType_DYNAMIC)) { + // otherwise, if the lhs is dynamic, but the rhs is not, we + // need to update the variable's dynamic source as "current SESE" + plan.addDynAssign(lhs); + } + + // only break if this is an ASSIGN op node, + // otherwise fall through to default case + break; } } - // note that FlatOpNode's that aren't ASSIGN - // fall through to this default case - default: { + // note that FlatOpNode's that aren't ASSIGN + // fall through to this default case + default: { // a node with no live set has nothing to stall for - if( liveSetIn == null ) { - break; + if (liveSetIn == null) { + break; } TempDescriptor[] readarray = fn.readsTemps(); - for( int i = 0; i < readarray.length; i++ ) { + for (int i = 0; i < readarray.length; i++) { TempDescriptor readtmp = readarray[i]; - // ignore temps that are definitely available - // when considering to stall on it - if( !notAvailSetIn.contains( readtmp ) ) { - continue; - } + // ignore temps that are definitely available + // when considering to stall on it + if (!notAvailSetIn.contains(readtmp)) { + continue; + } - // check the source type of this variable + // check the source type of this variable VSTWrapper vstIfStatic = new VSTWrapper(); - Integer srcType - = vstTableIn.getRefVarSrcType( readtmp, - currentSESE, - vstIfStatic - ); - - if( srcType.equals( VarSrcTokTable.SrcType_DYNAMIC ) ) { - // 1) It is not clear statically where this variable will - // come from, so dynamically we must keep track - // along various control paths, and therefore when we stall, - // just stall for the exact thing we need and move on - plan.addDynamicStall( readtmp ); - currentSESE.addDynamicVar( readtmp ); - - } else if( srcType.equals( VarSrcTokTable.SrcType_STATIC ) ) { - // 2) Single token/age pair: Stall for token/age pair, and copy - // all live variables with same token/age pair at the same - // time. This is the same stuff that the notavaialable analysis - // marks as now available. - VariableSourceToken vst = vstIfStatic.vst; - - Iterator availItr = - vstTableIn.get( vst.getSESE(), vst.getAge() ).iterator(); - - while( availItr.hasNext() ) { - VariableSourceToken vstAlsoAvail = availItr.next(); - - // only grab additional stuff that is live - Set copySet = new HashSet(); - - Iterator refVarItr = vstAlsoAvail.getRefVars().iterator(); - while( refVarItr.hasNext() ) { - TempDescriptor refVar = refVarItr.next(); - if( liveSetIn.contains( refVar ) ) { - copySet.add( refVar ); - } - } + Integer srcType = vstTableIn.getRefVarSrcType(readtmp, currentSESE, vstIfStatic); + + if (srcType.equals(VarSrcTokTable.SrcType_DYNAMIC)) { + // 1) It is not clear statically where this variable will + // come from, so dynamically we must keep track + // along various control paths, and therefore when we stall, + // just stall for the exact thing we need and move on + plan.addDynamicStall(readtmp); + currentSESE.addDynamicVar(readtmp); + + } else if (srcType.equals(VarSrcTokTable.SrcType_STATIC)) { + // 2) Single token/age pair: Stall for token/age pair, and copy + // all live variables with same token/age pair at the same + // time. This is the same stuff that the notavaialable analysis + // marks as now available. + VariableSourceToken vst = vstIfStatic.vst; - if( !copySet.isEmpty() ) { - plan.addStall2CopySet( vstAlsoAvail, copySet ); - } - } + Iterator availItr = + vstTableIn.get(vst.getSESE(), vst.getAge()).iterator(); - } else { - // the other case for srcs is READY, so do nothing - } + while (availItr.hasNext()) { + VariableSourceToken vstAlsoAvail = availItr.next(); - // assert that everything being stalled for is in the - // "not available" set coming into this flat node and - // that every VST identified is in the possible "stall set" - // that represents VST's from children SESE's + // only grab additional stuff that is live + Set copySet = new HashSet(); - } - } break; - - } // end switch + Iterator refVarItr = vstAlsoAvail.getRefVars().iterator(); + while (refVarItr.hasNext()) { + TempDescriptor refVar = refVarItr.next(); + if (liveSetIn.contains(refVar)) { + copySet.add(refVar); + } + } + + if (!copySet.isEmpty()) { + plan.addStall2CopySet(vstAlsoAvail, copySet); + } + } + + } else { + // the other case for srcs is READY, so do nothing + } + + // assert that everything being stalled for is in the + // "not available" set coming into this flat node and + // that every VST identified is in the possible "stall set" + // that represents VST's from children SESE's + } + } + break; + + } // end switch // identify sese-age pairs that are statically useful // and should have an associated SESE variable in code @@ -952,71 +915,61 @@ private void codePlansForward( FlatMethod fm ) { // AND ALWAYS GIVE NAMES TO PARENTS Set staticSet = vstTableIn.get(); Iterator vstItr = staticSet.iterator(); - while( vstItr.hasNext() ) { + while (vstItr.hasNext()) { VariableSourceToken vst = vstItr.next(); // placeholder source tokens are useful results, but // the placeholder static name is never needed - if( vst.getSESE().getIsCallerSESEplaceholder() ) { - continue; + if (vst.getSESE().getIsCallerSESEplaceholder()) { + continue; } FlatSESEEnterNode sese = currentSESE; - while( sese != null ) { - sese.addNeededStaticName( - new SESEandAgePair( vst.getSESE(), vst.getAge() ) - ); - sese.mustTrackAtLeastAge( vst.getAge() ); - - sese = sese.getParent(); + while (sese != null) { + sese.addNeededStaticName(new SESEandAgePair(vst.getSESE(), vst.getAge())); + sese.mustTrackAtLeastAge(vst.getAge()); + + sese = sese.getParent(); } } + codePlans.put(fn, plan); - codePlans.put( fn, plan ); - - - // if any variables at this-node-*dot* have a static source (exactly one vst) + // if any variables at this-node-*dot* have a static source (exactly one + // vst) // but go to a dynamic source at next-node-*dot*, create a new IR graph // node on that edge to track the sources dynamically - VarSrcTokTable thisVstTable = variableResults.get( fn ); - for( int i = 0; i < fn.numNext(); i++ ) { - FlatNode nn = fn.getNext( i ); - VarSrcTokTable nextVstTable = variableResults.get( nn ); - Set nextLiveIn = livenessRootView.get( nn ); + VarSrcTokTable thisVstTable = variableResults.get(fn); + for (int i = 0; i < fn.numNext(); i++) { + FlatNode nn = fn.getNext(i); + VarSrcTokTable nextVstTable = variableResults.get(nn); + Set nextLiveIn = livenessRootView.get(nn); // the table can be null if it is one of the few IR nodes // completely outside of the root SESE scope - if( nextVstTable != null && nextLiveIn != null ) { - - Hashtable readyOrStatic2dynamicSet = - thisVstTable.getReadyOrStatic2DynamicSet( nextVstTable, - nextLiveIn, - currentSESE - ); - - if( !readyOrStatic2dynamicSet.isEmpty() ) { - - // either add these results to partial fixed-point result - // or make a new one if we haven't made any here yet - FlatEdge fe = new FlatEdge( fn, nn ); - FlatWriteDynamicVarNode fwdvn = wdvNodesToSpliceIn.get( fe ); - - if( fwdvn == null ) { - fwdvn = new FlatWriteDynamicVarNode( fn, - nn, - readyOrStatic2dynamicSet, - currentSESE - ); - wdvNodesToSpliceIn.put( fe, fwdvn ); - } else { - fwdvn.addMoreVar2Src( readyOrStatic2dynamicSet ); - } - } + if (nextVstTable != null && nextLiveIn != null) { + + Hashtable readyOrStatic2dynamicSet = + thisVstTable.getReadyOrStatic2DynamicSet(nextVstTable, nextLiveIn, currentSESE); + + if (!readyOrStatic2dynamicSet.isEmpty()) { + + // either add these results to partial fixed-point result + // or make a new one if we haven't made any here yet + FlatEdge fe = new FlatEdge(fn, nn); + FlatWriteDynamicVarNode fwdvn = wdvNodesToSpliceIn.get(fe); + + if (fwdvn == null) { + fwdvn = new FlatWriteDynamicVarNode(fn, nn, readyOrStatic2dynamicSet, currentSESE); + wdvNodesToSpliceIn.put(fe, fwdvn); + } else { + fwdvn.addMoreVar2Src(readyOrStatic2dynamicSet); + } + } } } } - + private void makeConflictGraph(FlatMethod fm) { Set flatNodesToVisit = new HashSet(); @@ -1053,7 +1006,6 @@ private void codePlansForward( FlatMethod fm ) { } } - private void conflictGraph_nodeAction(FlatNode fn, FlatSESEEnterNode currentSESE) { @@ -1177,7 +1129,7 @@ private void codePlansForward( FlatMethod fm ) { ConflictGraph conflictGraph = sese2conflictGraph.get(sese); if (useReachInfo) { // clear current conflict before recalculating with reachability info - conflictGraph.clearAllConflictEdge(); + conflictGraph.clearAllConflictEdge(); conflictGraph.setDisJointAnalysis(disjointAnalysisReach); conflictGraph.setFMEnclosing(sese.getfmEnclosing()); } @@ -1185,7 +1137,7 @@ private void codePlansForward( FlatMethod fm ) { sese2conflictGraph.put(sese, conflictGraph); } } - + private void writeConflictGraph() { Enumeration keyEnum = sese2conflictGraph.keys(); while (keyEnum.hasMoreElements()) { @@ -1201,7 +1153,7 @@ private void codePlansForward( FlatMethod fm ) { } } } - + private void synthesizeLocks() { Set> graphEntrySet = sese2conflictGraph.entrySet(); for (Iterator iterator = graphEntrySet.iterator(); iterator.hasNext();) { @@ -1211,7 +1163,7 @@ private void codePlansForward( FlatMethod fm ) { calculateCovering(conflictGraph); } } - + private void calculateCovering(ConflictGraph conflictGraph) { uniqueLockSetId = 0; // reset lock counter for every new conflict graph HashSet fineToCover = new HashSet(); @@ -1299,8 +1251,8 @@ private void codePlansForward( FlatMethod fm ) { // but the edge must remain uncovered. changed = true; - - if(seseLock.containsConflictNode(newNode)){ + + if (seseLock.containsConflictNode(newNode)) { seseLock.addEdge(edge); fineToCover.remove(edge); break; @@ -1369,13 +1321,13 @@ private void codePlansForward( FlatMethod fm ) { seseLock.addConflictNode(edge.getVertexU(), type); } else { if (edge.getVertexU().isStallSiteNode()) { - if(edge.getVertexU().getWriteEffectSet().isEmpty()){ + if (edge.getVertexU().getWriteEffectSet().isEmpty()) { type = ConflictNode.PARENT_READ; - }else{ + } else { type = ConflictNode.PARENT_WRITE; } } else { - type = ConflictNode.COARSE; + type = ConflictNode.COARSE; } seseLock.addConflictNode(edge.getVertexU(), type); } @@ -1389,12 +1341,12 @@ private void codePlansForward( FlatMethod fm ) { } seseLock.addConflictNode(edge.getVertexV(), type); } else { - if (edge.getVertexV().isStallSiteNode()) { - if(edge.getVertexV().getWriteEffectSet().isEmpty()){ + if (edge.getVertexV().isStallSiteNode()) { + if (edge.getVertexV().getWriteEffectSet().isEmpty()) { type = ConflictNode.PARENT_READ; - }else{ + } else { type = ConflictNode.PARENT_WRITE; - } + } } else { type = ConflictNode.COARSE; } @@ -1411,10 +1363,9 @@ private void codePlansForward( FlatMethod fm ) { // new node has a coarse-grained edge to all fine-read, fine-write, // parent changed = true; - - if(newNode.isInVarNode() && - (!seseLock.hasSelfCoarseEdge(newNode)) && - seseLock.hasCoarseEdgeWithParentCoarse(newNode)){ + + if (newNode.isInVarNode() && (!seseLock.hasSelfCoarseEdge(newNode)) + && seseLock.hasCoarseEdgeWithParentCoarse(newNode)) { // this case can't be covered by this queue coarseToCover.remove(edge); break; @@ -1474,38 +1425,38 @@ private void codePlansForward( FlatMethod fm ) { conflictGraph2SESELock.put(conflictGraph, lockSet); } - - public ConflictGraph getConflictGraph(FlatNode sese){ - return sese2conflictGraph.get(sese); + + public ConflictGraph getConflictGraph(FlatNode sese) { + return sese2conflictGraph.get(sese); } - - public Set getLockMappings(ConflictGraph graph){ + + public Set getLockMappings(ConflictGraph graph) { return conflictGraph2SESELock.get(graph); } - + public Set getAllSESEs() { return rblockRel.getAllSESEs(); } - + public FlatSESEEnterNode getMainSESE() { return rblockRel.getMainSESE(); } - - public void writeReports( String timeReport ) throws java.io.IOException { - - BufferedWriter bw = new BufferedWriter( new FileWriter( "mlpReport_summary.txt" ) ); - bw.write( "MLP Analysis Results\n\n" ); - bw.write( timeReport+"\n\n" ); - printSESEHierarchy( bw ); - bw.write( "\n" ); - printSESEInfo( bw ); + + public void writeReports(String timeReport) throws java.io.IOException { + + BufferedWriter bw = new BufferedWriter(new FileWriter("mlpReport_summary.txt")); + bw.write("MLP Analysis Results\n\n"); + bw.write(timeReport + "\n\n"); + printSESEHierarchy(bw); + bw.write("\n"); + printSESEInfo(bw); bw.close(); Iterator methItr = disjointAnalysisTaints.getDescriptorsToAnalyze().iterator(); - while( methItr.hasNext() ) { - MethodDescriptor md = (MethodDescriptor) methItr.next(); - FlatMethod fm = state.getMethodFlat( md ); - if (fm!=null) { + while (methItr.hasNext()) { + MethodDescriptor md = (MethodDescriptor) methItr.next(); + FlatMethod fm = state.getMethodFlat(md); + if (fm != null) { bw = new BufferedWriter(new FileWriter("mlpReport_" + md.getClassMethodName() + md.getSafeMethodDescriptor() + ".txt")); @@ -1527,91 +1478,86 @@ private void codePlansForward( FlatMethod fm ) { } } } - - private void printSESEHierarchy( BufferedWriter bw ) throws java.io.IOException { - bw.write( "SESE Hierarchy\n--------------\n" ); + + private void printSESEHierarchy(BufferedWriter bw) throws java.io.IOException { + bw.write("SESE Hierarchy\n--------------\n"); Iterator rootItr = rblockRel.getRootSESEs().iterator(); - while( rootItr.hasNext() ) { + while (rootItr.hasNext()) { FlatSESEEnterNode root = rootItr.next(); - if( root.getIsCallerSESEplaceholder() ) { - if( !root.getChildren().isEmpty() ) { - printSESEHierarchyTree( bw, root, 0 ); - } + if (root.getIsCallerSESEplaceholder()) { + if (!root.getChildren().isEmpty()) { + printSESEHierarchyTree(bw, root, 0); + } } else { - printSESEHierarchyTree( bw, root, 0 ); + printSESEHierarchyTree(bw, root, 0); } } } - private void printSESEHierarchyTree( BufferedWriter bw, - FlatSESEEnterNode fsen, - int depth - ) throws java.io.IOException { - for( int i = 0; i < depth; ++i ) { - bw.write( " " ); + private void printSESEHierarchyTree(BufferedWriter bw, FlatSESEEnterNode fsen, int depth) + throws java.io.IOException { + for (int i = 0; i < depth; ++i) { + bw.write(" "); } - bw.write( "- "+fsen.getPrettyIdentifier()+"\n" ); + bw.write("- " + fsen.getPrettyIdentifier() + "\n"); Iterator childItr = fsen.getChildren().iterator(); - while( childItr.hasNext() ) { + while (childItr.hasNext()) { FlatSESEEnterNode fsenChild = childItr.next(); - printSESEHierarchyTree( bw, fsenChild, depth + 1 ); + printSESEHierarchyTree(bw, fsenChild, depth + 1); } } - - private void printSESEInfo( BufferedWriter bw ) throws java.io.IOException { - bw.write("\nSESE info\n-------------\n" ); + private void printSESEInfo(BufferedWriter bw) throws java.io.IOException { + bw.write("\nSESE info\n-------------\n"); Iterator rootItr = rblockRel.getRootSESEs().iterator(); - while( rootItr.hasNext() ) { + while (rootItr.hasNext()) { FlatSESEEnterNode root = rootItr.next(); - if( root.getIsCallerSESEplaceholder() ) { - if( !root.getChildren().isEmpty() ) { - printSESEInfoTree( bw, root ); - } + if (root.getIsCallerSESEplaceholder()) { + if (!root.getChildren().isEmpty()) { + printSESEInfoTree(bw, root); + } } else { - printSESEInfoTree( bw, root ); + printSESEInfoTree(bw, root); } } } - - public DisjointAnalysis getDisjointAnalysis(){ - return disjointAnalysisReach; + + public DisjointAnalysis getDisjointAnalysis() { + return disjointAnalysisTaints; } - private void printSESEInfoTree( BufferedWriter bw, - FlatSESEEnterNode fsen - ) throws java.io.IOException { + private void printSESEInfoTree(BufferedWriter bw, FlatSESEEnterNode fsen) + throws java.io.IOException { - if( !fsen.getIsCallerSESEplaceholder() ) { - bw.write( "SESE "+fsen.getPrettyIdentifier()+" {\n" ); + if (!fsen.getIsCallerSESEplaceholder()) { + bw.write("SESE " + fsen.getPrettyIdentifier() + " {\n"); - bw.write( " in-set: "+fsen.getInVarSet()+"\n" ); + bw.write(" in-set: " + fsen.getInVarSet() + "\n"); Iterator tItr = fsen.getInVarSet().iterator(); - while( tItr.hasNext() ) { - TempDescriptor inVar = tItr.next(); - if( fsen.getReadyInVarSet().contains( inVar ) ) { - bw.write( " (ready) "+inVar+"\n" ); - } - if( fsen.getStaticInVarSet().contains( inVar ) ) { - bw.write( " (static) "+inVar+" from "+ - fsen.getStaticInVarSrc( inVar )+"\n" ); - } - if( fsen.getDynamicInVarSet().contains( inVar ) ) { - bw.write( " (dynamic)"+inVar+"\n" ); - } + while (tItr.hasNext()) { + TempDescriptor inVar = tItr.next(); + if (fsen.getReadyInVarSet().contains(inVar)) { + bw.write(" (ready) " + inVar + "\n"); + } + if (fsen.getStaticInVarSet().contains(inVar)) { + bw.write(" (static) " + inVar + " from " + fsen.getStaticInVarSrc(inVar) + "\n"); + } + if (fsen.getDynamicInVarSet().contains(inVar)) { + bw.write(" (dynamic)" + inVar + "\n"); + } } - - bw.write( " Dynamic vars to manage: "+fsen.getDynamicVarSet()+"\n"); - - bw.write( " out-set: "+fsen.getOutVarSet()+"\n" ); - bw.write( "}\n" ); + + bw.write(" Dynamic vars to manage: " + fsen.getDynamicVarSet() + "\n"); + + bw.write(" out-set: " + fsen.getOutVarSet() + "\n"); + bw.write("}\n"); } Iterator childItr = fsen.getChildren().iterator(); - while( childItr.hasNext() ) { + while (childItr.hasNext()) { FlatSESEEnterNode fsenChild = childItr.next(); - printSESEInfoTree( bw, fsenChild ); + printSESEInfoTree(bw, fsenChild); } } diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java index 0c57e83e..5159f7eb 100644 --- a/Robust/src/IR/Flat/BuildCode.java +++ b/Robust/src/IR/Flat/BuildCode.java @@ -23,7 +23,9 @@ import Analysis.Locality.DCWrapper; import Analysis.Locality.DelayComputation; import Analysis.Locality.BranchAnalysis; import Analysis.CallGraph.CallGraph; +import Analysis.Disjoint.Effect; import Analysis.Disjoint.ReachGraph; +import Analysis.Disjoint.Taint; import Analysis.OoOJava.OoOJavaAnalysis; import Analysis.Prefetch.*; import Analysis.Loops.WriteBarrier; @@ -257,12 +259,24 @@ public class BuildCode { FlatSESEEnterNode fsen = seseit.next(); initializeSESE( fsen ); - // invoke rcr + /* if(state.RCR){ -// FlatMethod fm=fsen.getfmEnclosing(); -// ReachGraph rg=oooa.getDisjointAnalysis().getReachGraph(fm.getMethod()); + if(!fsen.getIsCallerSESEplaceholder() && fsen.getParent()!=null){ + + FlatMethod fm=fsen.getfmEnclosing(); + + //reach graph + ReachGraph rg=oooa.getDisjointAnalysis().getReachGraph(fm.getMethod()); + + //get effect set + Hashtable> effects=oooa.getDisjointAnalysis().getEffectsAnalysis().get(fsen); + + //get conflict set + Analysis.OoOJava.ConflictGraph conflictGraph=oooa.getConflictGraph(fsen.getParent()); + Hashtable> conflicts=conflictGraph.getConflictEffectSet(fsen); + } } - + */ } } -- 2.34.1