DASCA
/
WALA
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

refactoring of relations 

git-svn-id: https://wala.svn.sourceforge.net/svnroot/wala/trunk@783 f5eafffb-2e1d-0410-98e4-8ec43c5233c4
This commit is contained in:
sjfink 2007-02-23 17:07:21 +00:00
parent 4755779801
commit d60734d54b
16 changed files with 106 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
com.ibm.wala.core/src/com/ibm/wala/analysis/pointers/BasicHeapGraph.java
View File

@ -36,8 +36,8 @@ import com.ibm.wala.util.graph.NodeManager;
import com.ibm.wala.util.graph.NumberedGraph; import com.ibm.wala.util.graph.NumberedGraph;
import com.ibm.wala.util.graph.NumberedNodeManager; import com.ibm.wala.util.graph.NumberedNodeManager;
import com.ibm.wala.util.graph.impl.NumberedNodeIterator; import com.ibm.wala.util.graph.impl.NumberedNodeIterator;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.MutableMapping; import com.ibm.wala.util.intset.MutableMapping;
import com.ibm.wala.util.intset.MutableSparseIntSet; import com.ibm.wala.util.intset.MutableSparseIntSet;
@ -131,7 +131,7 @@ public class BasicHeapGraph extends HeapGraph {
} }
}; };
final IBinaryNonNegativeIntRelation pred = computePredecessors(nodeMgr); final IBinaryNaturalRelation pred = computePredecessors(nodeMgr);
final IntFunction<Object> toNode = new IntFunction<Object>() { final IntFunction<Object> toNode = new IntFunction<Object>() {
public Object apply(int i) { public Object apply(int i) {
return nodeMgr.getNode(i); return nodeMgr.getNode(i);
@ -281,9 +281,9 @@ public class BasicHeapGraph extends HeapGraph {
/** /**
* @return R, y \in R(x,y) if the node y is a predecessor of node x * @return R, y \in R(x,y) if the node y is a predecessor of node x
*/ */
private IBinaryNonNegativeIntRelation computePredecessors(NumberedNodeManager<Object> nodeManager) { private IBinaryNaturalRelation computePredecessors(NumberedNodeManager<Object> nodeManager) {
BasicNonNegativeIntRelation R = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE }, BasicNaturalRelation R = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE },
BasicNonNegativeIntRelation.SIMPLE); BasicNaturalRelation.SIMPLE);
// we split the following loops to improve temporal locality, // we split the following loops to improve temporal locality,
// particularly for locals // particularly for locals
@ -293,7 +293,7 @@ public class BasicHeapGraph extends HeapGraph {
return R; return R;
} }
private void computePredecessorsForNonLocals(NumberedNodeManager<Object> nodeManager, BasicNonNegativeIntRelation R) { private void computePredecessorsForNonLocals(NumberedNodeManager<Object> nodeManager, BasicNaturalRelation R) {
// Note: we run this loop backwards on purpose, to avoid lots of resizing of // Note: we run this loop backwards on purpose, to avoid lots of resizing of
// bitvectors // bitvectors
// in the backing relation. i.e., we will add the biggest bits first. // in the backing relation. i.e., we will add the biggest bits first.
@ -321,7 +321,7 @@ public class BasicHeapGraph extends HeapGraph {
* traverse locals in order, first by node, then by value number: attempt to * traverse locals in order, first by node, then by value number: attempt to
* improve locality * improve locality
*/ */
private void computePredecessorsForLocals(NumberedNodeManager<Object> nodeManager, BasicNonNegativeIntRelation R) { private void computePredecessorsForLocals(NumberedNodeManager<Object> nodeManager, BasicNaturalRelation R) {
ArrayList<LocalPointerKey> list = new ArrayList<LocalPointerKey>(); ArrayList<LocalPointerKey> list = new ArrayList<LocalPointerKey>();
for (Iterator it = nodeManager.iterateNodes(); it.hasNext();) { for (Iterator it = nodeManager.iterateNodes(); it.hasNext();) {

6
com.ibm.wala.core/src/com/ibm/wala/cfg/AbstractCFG.java
View File

@ -28,7 +28,7 @@ import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.graph.impl.DelegatingNumberedNodeManager; import com.ibm.wala.util.graph.impl.DelegatingNumberedNodeManager;
import com.ibm.wala.util.graph.impl.NumberedNodeIterator; import com.ibm.wala.util.graph.impl.NumberedNodeIterator;
import com.ibm.wala.util.graph.impl.SparseNumberedEdgeManager; import com.ibm.wala.util.graph.impl.SparseNumberedEdgeManager;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.BitVector; import com.ibm.wala.util.intset.BitVector;
import com.ibm.wala.util.intset.FixedSizeBitVector; import com.ibm.wala.util.intset.FixedSizeBitVector;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
@ -56,13 +56,13 @@ public abstract class AbstractCFG implements ControlFlowGraph, Constants {
* An object to track most normal edges in this cfg * An object to track most normal edges in this cfg
*/ */
private SparseNumberedEdgeManager<IBasicBlock> normalEdgeManager = new SparseNumberedEdgeManager<IBasicBlock>(nodeManager, 2, private SparseNumberedEdgeManager<IBasicBlock> normalEdgeManager = new SparseNumberedEdgeManager<IBasicBlock>(nodeManager, 2,
BasicNonNegativeIntRelation.SIMPLE); BasicNaturalRelation.SIMPLE);
/** /**
* An object to track not-to-exit exceptional edges in this cfg * An object to track not-to-exit exceptional edges in this cfg
*/ */
private SparseNumberedEdgeManager<IBasicBlock> exceptionalEdgeManager = new SparseNumberedEdgeManager<IBasicBlock>(nodeManager, private SparseNumberedEdgeManager<IBasicBlock> exceptionalEdgeManager = new SparseNumberedEdgeManager<IBasicBlock>(nodeManager,
0, BasicNonNegativeIntRelation.SIMPLE); 0, BasicNaturalRelation.SIMPLE);
/** /**
* Which basic blocks have a normal edge to exit()? * Which basic blocks have a normal edge to exit()?

14
com.ibm.wala.core/src/com/ibm/wala/dataflow/IFDS/CallFlowEdges.java
View File

@ -11,9 +11,9 @@
package com.ibm.wala.dataflow.IFDS; package com.ibm.wala.dataflow.IFDS;
import com.ibm.wala.util.debug.Trace; import com.ibm.wala.util.debug.Trace;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.BitVectorIntSet; import com.ibm.wala.util.intset.BitVectorIntSet;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.MutableSparseIntSet; import com.ibm.wala.util.intset.MutableSparseIntSet;
import com.ibm.wala.util.intset.SparseIntSet; import com.ibm.wala.util.intset.SparseIntSet;
@ -39,7 +39,7 @@ public class CallFlowEdges {
* TODO: more representation optimization. A special represention for triples? * TODO: more representation optimization. A special represention for triples?
* sparse representations for CFG? exploit shorts for ints? * sparse representations for CFG? exploit shorts for ints?
*/ */
private final SparseVector<IBinaryNonNegativeIntRelation> edges = new SparseVector<IBinaryNonNegativeIntRelation>(1, 1.1f); private final SparseVector<IBinaryNaturalRelation> edges = new SparseVector<IBinaryNaturalRelation>(1, 1.1f);
/** /**
* a map from integer d1 -> int set. * a map from integer d1 -> int set.
@ -74,11 +74,11 @@ public class CallFlowEdges {
} }
s.add(c); s.add(c);
} else { } else {
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) edges.get(c); IBinaryNaturalRelation R = (IBinaryNaturalRelation) edges.get(c);
if (R == null) { if (R == null) {
// we expect the first dimention of R to be dense, the second sparse // we expect the first dimention of R to be dense, the second sparse
R = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, R = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY },
BasicNonNegativeIntRelation.TWO_LEVEL); BasicNaturalRelation.TWO_LEVEL);
edges.set(c, R); edges.set(c, R);
} }
R.add(d2, d1); R.add(d2, d1);
@ -93,7 +93,7 @@ public class CallFlowEdges {
*/ */
public IntSet getCallFlowSources(int c, int d2) { public IntSet getCallFlowSources(int c, int d2) {
BitVectorIntSet s = (BitVectorIntSet) identityEdges.get(d2); BitVectorIntSet s = (BitVectorIntSet) identityEdges.get(d2);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) edges.get(c); IBinaryNaturalRelation R = (IBinaryNaturalRelation) edges.get(c);
IntSet result = null; IntSet result = null;
if (R == null) { if (R == null) {
if (s != null) { if (s != null) {

46
com.ibm.wala.core/src/com/ibm/wala/dataflow/IFDS/LocalPathEdges.java
View File

@ -14,9 +14,9 @@ import java.util.Iterator;
import com.ibm.wala.util.debug.Assertions; import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.debug.Trace; import com.ibm.wala.util.debug.Trace;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.BitVectorIntSet; import com.ibm.wala.util.intset.BitVectorIntSet;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntIterator; import com.ibm.wala.util.intset.IntIterator;
import com.ibm.wala.util.intset.IntPair; import com.ibm.wala.util.intset.IntPair;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
@ -58,7 +58,7 @@ public class LocalPathEdges {
* TODO: more representation optimization. A special represention for triples? * TODO: more representation optimization. A special represention for triples?
* sparse representations for CFG? exploit shorts for ints? * sparse representations for CFG? exploit shorts for ints?
*/ */
private final SparseVector<IBinaryNonNegativeIntRelation> paths = new SparseVector<IBinaryNonNegativeIntRelation>(1, 1.1f); private final SparseVector<IBinaryNaturalRelation> paths = new SparseVector<IBinaryNaturalRelation>(1, 1.1f);
/** /**
* If this is non-null, it holds a redundant representation of the paths * If this is non-null, it holds a redundant representation of the paths
@ -81,7 +81,7 @@ public class LocalPathEdges {
* to be dense in the first dimension 2) we need to support getReachable(), so * to be dense in the first dimension 2) we need to support getReachable(), so
* we design lookup to get the d2's for an (n,d1) pair. * we design lookup to get the d2's for an (n,d1) pair.
*/ */
private final SparseVector<IBinaryNonNegativeIntRelation> altPaths; private final SparseVector<IBinaryNaturalRelation> altPaths;
/** /**
* a map from integer d1 -> int set. * a map from integer d1 -> int set.
@ -105,7 +105,7 @@ public class LocalPathEdges {
* faster merge operations * faster merge operations
*/ */
public LocalPathEdges(boolean fastMerge) { public LocalPathEdges(boolean fastMerge) {
altPaths = fastMerge ? new SparseVector<IBinaryNonNegativeIntRelation>(1, 1.1f) : null; altPaths = fastMerge ? new SparseVector<IBinaryNaturalRelation>(1, 1.1f) : null;
} }
/** /**
@ -126,21 +126,21 @@ public class LocalPathEdges {
if (i == j) { if (i == j) {
addIdentityPathEdge(i, n); addIdentityPathEdge(i, n);
} else { } else {
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) paths.get(j); IBinaryNaturalRelation R = (IBinaryNaturalRelation) paths.get(j);
if (R == null) { if (R == null) {
// we expect the first dimention of R to be dense, the second sparse // we expect the first dimention of R to be dense, the second sparse
R = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, R = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY },
BasicNonNegativeIntRelation.TWO_LEVEL); BasicNaturalRelation.TWO_LEVEL);
paths.set(j, R); paths.set(j, R);
} }
R.add(n, i); R.add(n, i);
if (altPaths != null) { if (altPaths != null) {
IBinaryNonNegativeIntRelation R2 = (IBinaryNonNegativeIntRelation) altPaths.get(i); IBinaryNaturalRelation R2 = (IBinaryNaturalRelation) altPaths.get(i);
if (R2 == null) { if (R2 == null) {
// we expect the first dimention of R to be dense, the second sparse // we expect the first dimention of R to be dense, the second sparse
R2 = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, R2 = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY },
BasicNonNegativeIntRelation.TWO_LEVEL); BasicNaturalRelation.TWO_LEVEL);
altPaths.set(i, R2); altPaths.set(i, R2);
} }
R2.add(n, j); R2.add(n, j);
@ -169,11 +169,11 @@ public class LocalPathEdges {
s.add(n); s.add(n);
if (altPaths != null) { if (altPaths != null) {
IBinaryNonNegativeIntRelation R2 = (IBinaryNonNegativeIntRelation) altPaths.get(i); IBinaryNaturalRelation R2 = (IBinaryNaturalRelation) altPaths.get(i);
if (R2 == null) { if (R2 == null) {
// we expect the first dimention of R to be dense, the second sparse // we expect the first dimention of R to be dense, the second sparse
R2 = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, R2 = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY },
BasicNonNegativeIntRelation.TWO_LEVEL); BasicNaturalRelation.TWO_LEVEL);
altPaths.set(i, R2); altPaths.set(i, R2);
} }
R2.add(n, i); R2.add(n, i);
@ -202,11 +202,11 @@ public class LocalPathEdges {
} }
z.add(n); z.add(n);
if (altPaths != null) { if (altPaths != null) {
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) altPaths.get(0); IBinaryNaturalRelation R = (IBinaryNaturalRelation) altPaths.get(0);
if (R == null) { if (R == null) {
// we expect the first dimention of R to be dense, the second sparse // we expect the first dimention of R to be dense, the second sparse
R = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, R = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY },
BasicNonNegativeIntRelation.TWO_LEVEL); BasicNaturalRelation.TWO_LEVEL);
altPaths.set(0, R); altPaths.set(0, R);
} }
R.add(n, j); R.add(n, j);
@ -235,7 +235,7 @@ public class LocalPathEdges {
* path edges. null if none found * path edges. null if none found
*/ */
public IntSet getInverse(int n, int d2) { public IntSet getInverse(int n, int d2) {
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) paths.get(d2); IBinaryNaturalRelation R = (IBinaryNaturalRelation) paths.get(d2);
BitVectorIntSet s = (BitVectorIntSet) identityPaths.get(d2); BitVectorIntSet s = (BitVectorIntSet) identityPaths.get(d2);
BitVectorIntSet z = (BitVectorIntSet) zeroPaths.get(d2); BitVectorIntSet z = (BitVectorIntSet) zeroPaths.get(d2);
if (R == null) { if (R == null) {
@ -334,7 +334,7 @@ public class LocalPathEdges {
return false; return false;
} }
} else { } else {
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) paths.get(j); IBinaryNaturalRelation R = (IBinaryNaturalRelation) paths.get(j);
if (R == null) { if (R == null) {
return false; return false;
} }
@ -369,7 +369,7 @@ public class LocalPathEdges {
Iterator contents = paths.iterator(); Iterator contents = paths.iterator();
for (IntIterator it = paths.iterateIndices(); it.hasNext();) { for (IntIterator it = paths.iterateIndices(); it.hasNext();) {
int d2 = it.next(); int d2 = it.next();
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) contents.next(); IBinaryNaturalRelation R = (IBinaryNaturalRelation) contents.next();
if (R != null && R.contains(n, d1)) { if (R != null && R.contains(n, d1)) {
result.add(d2); result.add(d2);
} }
@ -402,7 +402,7 @@ public class LocalPathEdges {
*/ */
private IntSet getReachableFast(int n, int d1) { private IntSet getReachableFast(int n, int d1) {
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) altPaths.get(d1); IBinaryNaturalRelation R = (IBinaryNaturalRelation) altPaths.get(d1);
if (R != null) { if (R != null) {
return R.getRelated(n); return R.getRelated(n);
} }
@ -424,7 +424,7 @@ public class LocalPathEdges {
Iterator contents = paths.iterator(); Iterator contents = paths.iterator();
for (IntIterator it = paths.iterateIndices(); it.hasNext();) { for (IntIterator it = paths.iterateIndices(); it.hasNext();) {
int d2 = it.next(); int d2 = it.next();
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) contents.next(); IBinaryNaturalRelation R = (IBinaryNaturalRelation) contents.next();
if (R != null && R.getRelatedCount(n) > 0) { if (R != null && R.getRelatedCount(n) > 0) {
result.add(d2); result.add(d2);
} }
@ -466,7 +466,7 @@ public class LocalPathEdges {
public IntSet getReachedNodeNumbers() { public IntSet getReachedNodeNumbers() {
MutableSparseIntSet result = new MutableSparseIntSet(); MutableSparseIntSet result = new MutableSparseIntSet();
if (paths.size() > 0) { if (paths.size() > 0) {
for (IBinaryNonNegativeIntRelation R : paths) { for (IBinaryNaturalRelation R : paths) {
for (IntPair p : R) { for (IntPair p : R) {
result.add(p.getX()); result.add(p.getX());
} }

18
com.ibm.wala.core/src/com/ibm/wala/dataflow/IFDS/LocalSummaryEdges.java
View File

@ -13,8 +13,8 @@ package com.ibm.wala.dataflow.IFDS;
import java.util.Iterator; import java.util.Iterator;
import com.ibm.wala.util.debug.Trace; import com.ibm.wala.util.debug.Trace;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntPair; import com.ibm.wala.util.intset.IntPair;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.MutableSparseIntSet; import com.ibm.wala.util.intset.MutableSparseIntSet;
@ -49,7 +49,7 @@ public class LocalSummaryEdges {
* *
* TODO: more representation optimization. * TODO: more representation optimization.
*/ */
private final SparseVector<IBinaryNonNegativeIntRelation> summaries = new SparseVector<IBinaryNonNegativeIntRelation>(1, 1.1f); private final SparseVector<IBinaryNaturalRelation> summaries = new SparseVector<IBinaryNaturalRelation>(1, 1.1f);
/** /**
* Let (s_p,x) be an entry-exit pair, and let l := the long whose high word is * Let (s_p,x) be an entry-exit pair, and let l := the long whose high word is
@ -85,11 +85,11 @@ public class LocalSummaryEdges {
*/ */
public void insertSummaryEdge(int s_p, int x, int d1, int d2) { public void insertSummaryEdge(int s_p, int x, int d1, int d2) {
int n = getIndexForEntryExitPair(s_p, x); int n = getIndexForEntryExitPair(s_p, x);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) summaries.get(n); IBinaryNaturalRelation R = (IBinaryNaturalRelation) summaries.get(n);
if (R == null) { if (R == null) {
// we expect R to usually be sparse // we expect R to usually be sparse
R = new BasicNonNegativeIntRelation(new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, R = new BasicNaturalRelation(new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY },
BasicNonNegativeIntRelation.SIMPLE); BasicNaturalRelation.SIMPLE);
summaries.set(n, R); summaries.set(n, R);
} }
R.add(d1, d2); R.add(d1, d2);
@ -112,7 +112,7 @@ public class LocalSummaryEdges {
*/ */
public boolean contains(int s_p, int x, int d1, int d2) { public boolean contains(int s_p, int x, int d1, int d2) {
int n = getIndexForEntryExitPair(s_p, x); int n = getIndexForEntryExitPair(s_p, x);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) summaries.get(n); IBinaryNaturalRelation R = (IBinaryNaturalRelation) summaries.get(n);
if (R == null) { if (R == null) {
return false; return false;
} else { } else {
@ -132,7 +132,7 @@ public class LocalSummaryEdges {
*/ */
public IntSet getSummaryEdges(int s_p, int x, int d1) { public IntSet getSummaryEdges(int s_p, int x, int d1) {
int n = getIndexForEntryExitPair(s_p, x); int n = getIndexForEntryExitPair(s_p, x);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) summaries.get(n); IBinaryNaturalRelation R = (IBinaryNaturalRelation) summaries.get(n);
if (R == null) { if (R == null) {
return null; return null;
} else { } else {
@ -154,7 +154,7 @@ public class LocalSummaryEdges {
*/ */
public IntSet getInvertedSummaryEdgesForTarget(int s_p, int x, int d2) { public IntSet getInvertedSummaryEdgesForTarget(int s_p, int x, int d2) {
int n = getIndexForEntryExitPair(s_p, x); int n = getIndexForEntryExitPair(s_p, x);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) summaries.get(n); IBinaryNaturalRelation R = (IBinaryNaturalRelation) summaries.get(n);
if (R == null) { if (R == null) {
return null; return null;
} else { } else {

4
com.ibm.wala.core/src/com/ibm/wala/emf/wrappers/ETypeHierarchyWrapper.java
View File

@ -41,7 +41,7 @@ import com.ibm.wala.ecore.java.ETypeHierarchy;
import com.ibm.wala.ecore.java.JavaFactory; import com.ibm.wala.ecore.java.JavaFactory;
import com.ibm.wala.ecore.java.JavaPackage; import com.ibm.wala.ecore.java.JavaPackage;
import com.ibm.wala.util.debug.Assertions; import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.IntIterator; import com.ibm.wala.util.intset.IntIterator;
import com.ibm.wala.util.intset.IntPair; import com.ibm.wala.util.intset.IntPair;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
@ -57,7 +57,7 @@ import com.ibm.wala.util.intset.IntSet;
public class ETypeHierarchyWrapper { public class ETypeHierarchyWrapper {
private final EClassHierarchyWrapper cha; private final EClassHierarchyWrapper cha;
private final EInterfaceHierarchyWrapper iface; private final EInterfaceHierarchyWrapper iface;
private final BasicNonNegativeIntRelation implementR = new BasicNonNegativeIntRelation(); private final BasicNaturalRelation implementR = new BasicNaturalRelation();
/** /**
* @param t * @param t

8
com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/impl/ExplicitCallGraph.java
View File

@ -34,8 +34,8 @@ import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.debug.Trace; import com.ibm.wala.util.debug.Trace;
import com.ibm.wala.util.graph.EdgeManager; import com.ibm.wala.util.graph.EdgeManager;
import com.ibm.wala.util.graph.NumberedEdgeManager; import com.ibm.wala.util.graph.NumberedEdgeManager;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntIterator; import com.ibm.wala.util.intset.IntIterator;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.MutableIntSet; import com.ibm.wala.util.intset.MutableIntSet;
@ -358,8 +358,8 @@ public class ExplicitCallGraph extends BasicCallGraph implements BytecodeConstan
/** /**
* for each y, the {x | (x,y) is an edge) * for each y, the {x | (x,y) is an edge)
*/ */
final IBinaryNonNegativeIntRelation predecessors = new BasicNonNegativeIntRelation( final IBinaryNaturalRelation predecessors = new BasicNaturalRelation(
new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }, BasicNonNegativeIntRelation.SIMPLE); new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY }, BasicNaturalRelation.SIMPLE);
public IntSet getSuccNodeNumbers(CGNode node) { public IntSet getSuccNodeNumbers(CGNode node) {
ExplicitNode n = (ExplicitNode) node; ExplicitNode n = (ExplicitNode) node;

46
com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/propagation/PropagationGraph.java
View File

@ -43,8 +43,8 @@ import com.ibm.wala.util.graph.impl.GraphInverter;
import com.ibm.wala.util.graph.impl.SparseNumberedEdgeManager; import com.ibm.wala.util.graph.impl.SparseNumberedEdgeManager;
import com.ibm.wala.util.graph.traverse.DFS; import com.ibm.wala.util.graph.traverse.DFS;
import com.ibm.wala.util.heapTrace.HeapTracer; import com.ibm.wala.util.heapTrace.HeapTracer;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntIterator; import com.ibm.wala.util.intset.IntIterator;
import com.ibm.wala.util.intset.IntPair; import com.ibm.wala.util.intset.IntPair;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
@ -70,7 +70,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
/** /**
* Track edges (equations) that are not represented implicitly * Track edges (equations) that are not represented implicitly
*/ */
private final EdgeManager<INodeWithNumber> edgeManager = new SparseNumberedEdgeManager<INodeWithNumber>(nodeManager, 2, BasicNonNegativeIntRelation.SIMPLE); private final EdgeManager<INodeWithNumber> edgeManager = new SparseNumberedEdgeManager<INodeWithNumber>(nodeManager, 2, BasicNaturalRelation.SIMPLE);
private final DelegateGraph delegateGraph = new DelegateGraph(); private final DelegateGraph delegateGraph = new DelegateGraph();
@ -84,7 +84,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
* i op j is an equation in the graph * i op j is an equation in the graph
* *
*/ */
private final SmallMap<UnaryOperator,IBinaryNonNegativeIntRelation> implicitUnaryMap = new SmallMap<UnaryOperator,IBinaryNonNegativeIntRelation>(); private final SmallMap<UnaryOperator,IBinaryNaturalRelation> implicitUnaryMap = new SmallMap<UnaryOperator,IBinaryNaturalRelation>();
/** /**
* The inverse of relations in the implicit map * The inverse of relations in the implicit map
@ -92,7 +92,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
* for UnaryOperator op, let R be invImplicitMap.get(op) then (i,j) \in R * for UnaryOperator op, let R be invImplicitMap.get(op) then (i,j) \in R
* implies j op i is an equation in the graph * implies j op i is an equation in the graph
*/ */
private final SmallMap<UnaryOperator, IBinaryNonNegativeIntRelation> invImplicitUnaryMap = new SmallMap<UnaryOperator,IBinaryNonNegativeIntRelation>(); private final SmallMap<UnaryOperator, IBinaryNaturalRelation> invImplicitUnaryMap = new SmallMap<UnaryOperator,IBinaryNaturalRelation>();
/** /**
* Number of implicit unary equations registered * Number of implicit unary equations registered
@ -104,8 +104,8 @@ public class PropagationGraph extends AbstractFixedPointSystem {
* @param key * @param key
* @return a relation in map m corresponding to a key * @return a relation in map m corresponding to a key
*/ */
private IBinaryNonNegativeIntRelation findOrCreateRelation(Map<UnaryOperator, IBinaryNonNegativeIntRelation> m, UnaryOperator key) { private IBinaryNaturalRelation findOrCreateRelation(Map<UnaryOperator, IBinaryNaturalRelation> m, UnaryOperator key) {
IBinaryNonNegativeIntRelation result = m.get(key); IBinaryNaturalRelation result = m.get(key);
if (result == null) { if (result == null) {
result = makeRelation((AbstractOperator) key); result = makeRelation((AbstractOperator) key);
m.put(key, result); m.put(key, result);
@ -116,17 +116,17 @@ public class PropagationGraph extends AbstractFixedPointSystem {
/** /**
* @return a Relation object to track implicit equations using the operator * @return a Relation object to track implicit equations using the operator
*/ */
private IBinaryNonNegativeIntRelation makeRelation(AbstractOperator op) { private IBinaryNaturalRelation makeRelation(AbstractOperator op) {
byte[] implementation = null; byte[] implementation = null;
if (op instanceof AssignOperator) { if (op instanceof AssignOperator) {
// lots of assignments. // lots of assignments.
implementation = new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY, implementation = new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY,
BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }; BasicNaturalRelation.SIMPLE_SPACE_STINGY };
} else { } else {
// assume sparse assignments with any other operator. // assume sparse assignments with any other operator.
implementation = new byte[] { BasicNonNegativeIntRelation.SIMPLE_SPACE_STINGY }; implementation = new byte[] { BasicNaturalRelation.SIMPLE_SPACE_STINGY };
} }
return new BasicNonNegativeIntRelation(implementation, BasicNonNegativeIntRelation.SIMPLE); return new BasicNaturalRelation(implementation, BasicNaturalRelation.SIMPLE);
} }
/** /**
@ -266,11 +266,11 @@ public class PropagationGraph extends AbstractFixedPointSystem {
if (DEBUG) { if (DEBUG) {
Trace.println("lhs rhs " + lhs + " " + rhs); Trace.println("lhs rhs " + lhs + " " + rhs);
} }
IBinaryNonNegativeIntRelation R = findOrCreateRelation(implicitUnaryMap, (UnaryOperator) eq.getOperator()); IBinaryNaturalRelation R = findOrCreateRelation(implicitUnaryMap, (UnaryOperator) eq.getOperator());
boolean b = R.add(lhs, rhs); boolean b = R.add(lhs, rhs);
if (b) { if (b) {
implicitUnaryCount++; implicitUnaryCount++;
IBinaryNonNegativeIntRelation iR = findOrCreateRelation(invImplicitUnaryMap, (UnaryOperator) eq.getOperator()); IBinaryNaturalRelation iR = findOrCreateRelation(invImplicitUnaryMap, (UnaryOperator) eq.getOperator());
iR.add(rhs, lhs); iR.add(rhs, lhs);
} }
} }
@ -284,9 +284,9 @@ public class PropagationGraph extends AbstractFixedPointSystem {
if (DEBUG) { if (DEBUG) {
Trace.println("lhs rhs " + lhs + " " + rhs); Trace.println("lhs rhs " + lhs + " " + rhs);
} }
IBinaryNonNegativeIntRelation R = findOrCreateRelation(implicitUnaryMap, (UnaryOperator) eq.getOperator()); IBinaryNaturalRelation R = findOrCreateRelation(implicitUnaryMap, (UnaryOperator) eq.getOperator());
R.remove(lhs,rhs); R.remove(lhs,rhs);
IBinaryNonNegativeIntRelation iR = findOrCreateRelation(invImplicitUnaryMap, (UnaryOperator) eq.getOperator()); IBinaryNaturalRelation iR = findOrCreateRelation(invImplicitUnaryMap, (UnaryOperator) eq.getOperator());
iR.remove(rhs,lhs); iR.remove(rhs,lhs);
implicitUnaryCount--; implicitUnaryCount--;
} }
@ -435,7 +435,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
innerDelegate = null; innerDelegate = null;
while (outerKeyDelegate.hasNext()) { while (outerKeyDelegate.hasNext()) {
currentOperator = (UnaryOperator) outerKeyDelegate.next(); currentOperator = (UnaryOperator) outerKeyDelegate.next();
IBinaryNonNegativeIntRelation R = implicitUnaryMap.get(currentOperator); IBinaryNaturalRelation R = implicitUnaryMap.get(currentOperator);
Iterator it = R.iterator(); Iterator it = R.iterator();
if (it.hasNext()) { if (it.hasNext()) {
innerDelegate = it; innerDelegate = it;
@ -756,7 +756,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
Iterator<AbstractStatement> result = (Iterator<AbstractStatement>) delegateGraph.getSuccNodes(v); Iterator<AbstractStatement> result = (Iterator<AbstractStatement>) delegateGraph.getSuccNodes(v);
for (int i = 0; i < invImplicitUnaryMap.size(); i++) { for (int i = 0; i < invImplicitUnaryMap.size(); i++) {
UnaryOperator op = (UnaryOperator) invImplicitUnaryMap.getKey(i); UnaryOperator op = (UnaryOperator) invImplicitUnaryMap.getKey(i);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) invImplicitUnaryMap.getValue(i); IBinaryNaturalRelation R = (IBinaryNaturalRelation) invImplicitUnaryMap.getValue(i);
IntSet s = R.getRelated(number); IntSet s = R.getRelated(number);
if (s != null) { if (s != null) {
result = new CompoundIterator<AbstractStatement>(new ImplicitUseIterator(op, v, s), result); result = new CompoundIterator<AbstractStatement>(new ImplicitUseIterator(op, v, s), result);
@ -779,7 +779,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
Iterator<AbstractStatement> result = (Iterator<AbstractStatement>) delegateGraph.getPredNodes(v); Iterator<AbstractStatement> result = (Iterator<AbstractStatement>) delegateGraph.getPredNodes(v);
for (int i = 0; i < implicitUnaryMap.size(); i++) { for (int i = 0; i < implicitUnaryMap.size(); i++) {
UnaryOperator op = (UnaryOperator) implicitUnaryMap.getKey(i); UnaryOperator op = (UnaryOperator) implicitUnaryMap.getKey(i);
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) implicitUnaryMap.getValue(i); IBinaryNaturalRelation R = (IBinaryNaturalRelation) implicitUnaryMap.getValue(i);
IntSet s = R.getRelated(number); IntSet s = R.getRelated(number);
if (s != null) { if (s != null) {
result = new CompoundIterator<AbstractStatement>(new ImplicitDefIterator(op, s, v), result); result = new CompoundIterator<AbstractStatement>(new ImplicitDefIterator(op, s, v), result);
@ -803,7 +803,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
int result = delegateGraph.getSuccNodeCount(v); int result = delegateGraph.getSuccNodeCount(v);
for (Iterator it = invImplicitUnaryMap.keySet().iterator(); it.hasNext();) { for (Iterator it = invImplicitUnaryMap.keySet().iterator(); it.hasNext();) {
UnaryOperator op = (UnaryOperator) it.next(); UnaryOperator op = (UnaryOperator) it.next();
IBinaryNonNegativeIntRelation R = invImplicitUnaryMap.get(op); IBinaryNaturalRelation R = invImplicitUnaryMap.get(op);
IntSet s = R.getRelated(number); IntSet s = R.getRelated(number);
if (s != null) { if (s != null) {
result += s.size(); result += s.size();
@ -825,7 +825,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
int result = delegateGraph.getPredNodeCount(v); int result = delegateGraph.getPredNodeCount(v);
for (Iterator it = implicitUnaryMap.keySet().iterator(); it.hasNext();) { for (Iterator it = implicitUnaryMap.keySet().iterator(); it.hasNext();) {
UnaryOperator op = (UnaryOperator) it.next(); UnaryOperator op = (UnaryOperator) it.next();
IBinaryNonNegativeIntRelation R = implicitUnaryMap.get(op); IBinaryNaturalRelation R = implicitUnaryMap.get(op);
IntSet s = R.getRelated(number); IntSet s = R.getRelated(number);
if (s != null) { if (s != null) {
result += s.size(); result += s.size();
@ -866,7 +866,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
for (Iterator it = implicitUnaryMap.entrySet().iterator(); it.hasNext();) { for (Iterator it = implicitUnaryMap.entrySet().iterator(); it.hasNext();) {
count++; count++;
Map.Entry e = (Map.Entry) it.next(); Map.Entry e = (Map.Entry) it.next();
IBinaryNonNegativeIntRelation R = (IBinaryNonNegativeIntRelation) e.getValue(); IBinaryNaturalRelation R = (IBinaryNaturalRelation) e.getValue();
Trace.println("entry " + count); Trace.println("entry " + count);
R.performVerboseAction(); R.performVerboseAction();
HeapTracer.Result result = HeapTracer.traceHeap(Collections.singleton(R), false); HeapTracer.Result result = HeapTracer.traceHeap(Collections.singleton(R), false);
@ -904,7 +904,7 @@ public class PropagationGraph extends AbstractFixedPointSystem {
int lhs = eq.getLHS().getGraphNodeId(); int lhs = eq.getLHS().getGraphNodeId();
int rhs = eq.getRightHandSide().getGraphNodeId(); int rhs = eq.getRightHandSide().getGraphNodeId();
UnaryOperator op = (UnaryOperator) eq.getOperator(); UnaryOperator op = (UnaryOperator) eq.getOperator();
IBinaryNonNegativeIntRelation R = implicitUnaryMap.get(op); IBinaryNaturalRelation R = implicitUnaryMap.get(op);
if (R != null) { if (R != null) {
return R.contains(lhs, rhs); return R.contains(lhs, rhs);
} else { } else {

6
com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/propagation/rta/DelegatingExplicitCallGraph.java
View File

@ -21,9 +21,9 @@ import com.ibm.wala.ipa.callgraph.Context;
import com.ibm.wala.ipa.callgraph.impl.ExplicitCallGraph; import com.ibm.wala.ipa.callgraph.impl.ExplicitCallGraph;
import com.ibm.wala.ipa.cha.ClassHierarchy; import com.ibm.wala.ipa.cha.ClassHierarchy;
import com.ibm.wala.util.debug.Assertions; import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.BitVectorIntSet; import com.ibm.wala.util.intset.BitVectorIntSet;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntIterator; import com.ibm.wala.util.intset.IntIterator;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.MutableSharedBitVectorIntSet; import com.ibm.wala.util.intset.MutableSharedBitVectorIntSet;
@ -42,7 +42,7 @@ public class DelegatingExplicitCallGraph extends ExplicitCallGraph {
* delegateR(x,y) means that for at least one site, node number y delegates to * delegateR(x,y) means that for at least one site, node number y delegates to
* node number x. * node number x.
*/ */
private final IBinaryNonNegativeIntRelation delegateR = new BasicNonNegativeIntRelation(); private final IBinaryNaturalRelation delegateR = new BasicNaturalRelation();
/** /**
* @param cha * @param cha

6
com.ibm.wala.core/src/com/ibm/wala/ipa/slicer/HeapReachingDefs.java
View File

@ -47,10 +47,10 @@ import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.collections.Iterator2Collection; import com.ibm.wala.util.collections.Iterator2Collection;
import com.ibm.wala.util.collections.ObjectArrayMapping; import com.ibm.wala.util.collections.ObjectArrayMapping;
import com.ibm.wala.util.debug.Assertions; import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.BitVector; import com.ibm.wala.util.intset.BitVector;
import com.ibm.wala.util.intset.BitVectorIntSet; import com.ibm.wala.util.intset.BitVectorIntSet;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.MutableIntSet; import com.ibm.wala.util.intset.MutableIntSet;
import com.ibm.wala.util.intset.MutableSparseIntSet; import com.ibm.wala.util.intset.MutableSparseIntSet;
@ -444,7 +444,7 @@ public class HeapReachingDefs {
* HeapStatement.ReturnCaller for statement i, a NormalStatement * HeapStatement.ReturnCaller for statement i, a NormalStatement
* representing an invoke * representing an invoke
*/ */
private final IBinaryNonNegativeIntRelation heapReturnCaller = new BasicNonNegativeIntRelation(); private final IBinaryNaturalRelation heapReturnCaller = new BasicNaturalRelation();
public RD(CGNode node, ExpandedControlFlowGraph cfg, PointerAnalysis pa, OrdinalSetMapping<Statement> domain, public RD(CGNode node, ExpandedControlFlowGraph cfg, PointerAnalysis pa, OrdinalSetMapping<Statement> domain,
Map<SSAInstruction, NormalStatement> ssaInstruction2Statement, HeapExclusions exclusions) { Map<SSAInstruction, NormalStatement> ssaInstruction2Statement, HeapExclusions exclusions) {

4
com.ibm.wala.core/src/com/ibm/wala/ssa/IR.java
View File

@ -25,7 +25,7 @@ import com.ibm.wala.util.CompoundIterator;
import com.ibm.wala.util.StringStuff; import com.ibm.wala.util.StringStuff;
import com.ibm.wala.util.collections.HashMapFactory; import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.debug.Assertions; import com.ibm.wala.util.debug.Assertions;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.IntIterator; import com.ibm.wala.util.intset.IntIterator;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
@ -65,7 +65,7 @@ public abstract class IR {
/** /**
* Mapping from CallSiteReference program counters to instruction[] indices * Mapping from CallSiteReference program counters to instruction[] indices
*/ */
private final BasicNonNegativeIntRelation callSiteMapping = new BasicNonNegativeIntRelation(); private final BasicNaturalRelation callSiteMapping = new BasicNaturalRelation();
/** /**
* Mapping from NewSiteReference program counters to instruction[] indices * Mapping from NewSiteReference program counters to instruction[] indices

4
com.ibm.wala.core/src/com/ibm/wala/util/graph/impl/SlowSparseNumberedGraph.java
View File

@ -16,7 +16,7 @@ import com.ibm.wala.util.graph.AbstractNumberedGraph;
import com.ibm.wala.util.graph.EdgeManager; import com.ibm.wala.util.graph.EdgeManager;
import com.ibm.wala.util.graph.Graph; import com.ibm.wala.util.graph.Graph;
import com.ibm.wala.util.graph.NodeManager; import com.ibm.wala.util.graph.NodeManager;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
/** /**
* *
@ -43,7 +43,7 @@ public class SlowSparseNumberedGraph<T> extends AbstractNumberedGraph<T> {
* what is the "normal" number of out edges for a node? * what is the "normal" number of out edges for a node?
*/ */
public SlowSparseNumberedGraph(int normalOutCount) { public SlowSparseNumberedGraph(int normalOutCount) {
edgeManager = new SparseNumberedEdgeManager<T>(nodeManager, normalOutCount, BasicNonNegativeIntRelation.TWO_LEVEL); edgeManager = new SparseNumberedEdgeManager<T>(nodeManager, normalOutCount, BasicNaturalRelation.TWO_LEVEL);
} }
/* /*

22
com.ibm.wala.core/src/com/ibm/wala/util/graph/impl/SparseNumberedEdgeManager.java
View File

@ -16,9 +16,9 @@ import java.util.Iterator;
import com.ibm.wala.util.collections.EmptyIterator; import com.ibm.wala.util.collections.EmptyIterator;
import com.ibm.wala.util.graph.NumberedEdgeManager; import com.ibm.wala.util.graph.NumberedEdgeManager;
import com.ibm.wala.util.graph.NumberedNodeManager; import com.ibm.wala.util.graph.NumberedNodeManager;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
import com.ibm.wala.util.intset.BitVector; import com.ibm.wala.util.intset.BitVector;
import com.ibm.wala.util.intset.IBinaryNonNegativeIntRelation; import com.ibm.wala.util.intset.IBinaryNaturalRelation;
import com.ibm.wala.util.intset.IntSet; import com.ibm.wala.util.intset.IntSet;
import com.ibm.wala.util.intset.IntSetAction; import com.ibm.wala.util.intset.IntSetAction;
@ -41,7 +41,7 @@ public final class SparseNumberedEdgeManager<T> implements NumberedEdgeManager<T
* an object to track nodes * an object to track nodes
*/ */
public SparseNumberedEdgeManager(NumberedNodeManager<T> nodeManager) { public SparseNumberedEdgeManager(NumberedNodeManager<T> nodeManager) {
this(nodeManager, 0, BasicNonNegativeIntRelation.TWO_LEVEL); this(nodeManager, 0, BasicNaturalRelation.TWO_LEVEL);
} }
/** /**
@ -56,13 +56,13 @@ public final class SparseNumberedEdgeManager<T> implements NumberedEdgeManager<T
public SparseNumberedEdgeManager(NumberedNodeManager<T> nodeManager, int normalCase, byte delegateImpl) { public SparseNumberedEdgeManager(NumberedNodeManager<T> nodeManager, int normalCase, byte delegateImpl) {
this.nodeManager = nodeManager; this.nodeManager = nodeManager;
if (normalCase == 0) { if (normalCase == 0) {
successors = new BasicNonNegativeIntRelation(defaultImpl, delegateImpl); successors = new BasicNaturalRelation(defaultImpl, delegateImpl);
predecessors = new BasicNonNegativeIntRelation(defaultImpl, delegateImpl); predecessors = new BasicNaturalRelation(defaultImpl, delegateImpl);
} else { } else {
byte[] impl = new byte[normalCase]; byte[] impl = new byte[normalCase];
Arrays.fill(impl, BasicNonNegativeIntRelation.SIMPLE); Arrays.fill(impl, BasicNaturalRelation.SIMPLE);
successors = new BasicNonNegativeIntRelation(impl, delegateImpl); successors = new BasicNaturalRelation(impl, delegateImpl);
predecessors = new BasicNonNegativeIntRelation(impl, delegateImpl); predecessors = new BasicNaturalRelation(impl, delegateImpl);
} }
} }
@ -70,11 +70,11 @@ public final class SparseNumberedEdgeManager<T> implements NumberedEdgeManager<T
* The default implementation policy conservatively uses 2-level vectors, in * The default implementation policy conservatively uses 2-level vectors, in
* an attempt to somewhat optimize for space. * an attempt to somewhat optimize for space.
*/ */
private final static byte[] defaultImpl = new byte[] { BasicNonNegativeIntRelation.TWO_LEVEL }; private final static byte[] defaultImpl = new byte[] { BasicNaturalRelation.TWO_LEVEL };
private final IBinaryNonNegativeIntRelation successors; private final IBinaryNaturalRelation successors;
private final IBinaryNonNegativeIntRelation predecessors; private final IBinaryNaturalRelation predecessors;
/* /*
* (non-Javadoc) * (non-Javadoc)

4
com.ibm.wala.core/src/com/ibm/wala/util/graph/impl/SparseNumberedGraph.java
View File

@ -14,7 +14,7 @@ import com.ibm.wala.util.graph.AbstractNumberedGraph;
import com.ibm.wala.util.graph.EdgeManager; import com.ibm.wala.util.graph.EdgeManager;
import com.ibm.wala.util.graph.INodeWithNumber; import com.ibm.wala.util.graph.INodeWithNumber;
import com.ibm.wala.util.graph.NodeManager; import com.ibm.wala.util.graph.NodeManager;
import com.ibm.wala.util.intset.BasicNonNegativeIntRelation; import com.ibm.wala.util.intset.BasicNaturalRelation;
/** /**
A graph of numbered nodes, expected to have a fairly sparse edge structure. A graph of numbered nodes, expected to have a fairly sparse edge structure.
@ -42,7 +42,7 @@ public class SparseNumberedGraph<T extends INodeWithNumber> extends AbstractNumb
*/ */
public SparseNumberedGraph(int normalCase) { public SparseNumberedGraph(int normalCase) {
nodeManager = new DelegatingNumberedNodeManager<T>(); nodeManager = new DelegatingNumberedNodeManager<T>();
edgeManager = new SparseNumberedEdgeManager<T>(nodeManager, normalCase, BasicNonNegativeIntRelation.TWO_LEVEL); edgeManager = new SparseNumberedEdgeManager<T>(nodeManager, normalCase, BasicNaturalRelation.TWO_LEVEL);
} }
/** /**

6
com.ibm.wala.core/src/com/ibm/wala/util/intset/BasicNonNegativeIntRelation.java → com.ibm.wala.core/src/com/ibm/wala/util/intset/BasicNaturalRelation.java
View File

@ -25,7 +25,7 @@ import com.ibm.wala.util.debug.Trace;
* *
* @author sfink * @author sfink
*/ */
public final class BasicNonNegativeIntRelation implements IBinaryNonNegativeIntRelation { public final class BasicNaturalRelation implements IBinaryNaturalRelation {
private final static boolean VERBOSE = false; private final static boolean VERBOSE = false;
@ -74,7 +74,7 @@ public final class BasicNonNegativeIntRelation implements IBinaryNonNegativeIntR
* implemented with a SimpleIntVector, and the 2nd and 3rd are implemented * implemented with a SimpleIntVector, and the 2nd and 3rd are implemented
* with TwoLevelIntVector * with TwoLevelIntVector
*/ */
public BasicNonNegativeIntRelation(byte[] implementation, byte vectorImpl) { public BasicNaturalRelation(byte[] implementation, byte vectorImpl) {
smallStore = new IntVector[implementation.length]; smallStore = new IntVector[implementation.length];
for (int i = 0; i < implementation.length; i++) { for (int i = 0; i < implementation.length; i++) {
switch (implementation[i]) { switch (implementation[i]) {
@ -109,7 +109,7 @@ public final class BasicNonNegativeIntRelation implements IBinaryNonNegativeIntR
/** /**
* a Default contructor * a Default contructor
*/ */
public BasicNonNegativeIntRelation() { public BasicNaturalRelation() {
this(new byte[] { SIMPLE }, TWO_LEVEL); this(new byte[] { SIMPLE }, TWO_LEVEL);
} }

2
com.ibm.wala.core/src/com/ibm/wala/util/intset/IBinaryNonNegativeIntRelation.java → com.ibm.wala.core/src/com/ibm/wala/util/intset/IBinaryNaturalRelation.java
View File

@ -17,7 +17,7 @@ import com.ibm.wala.util.debug.VerboseAction;
* *
* @author sfink * @author sfink
*/ */
public interface IBinaryNonNegativeIntRelation extends VerboseAction, Iterable<IntPair> { public interface IBinaryNaturalRelation extends VerboseAction, Iterable<IntPair> {
/** /**
* Add (x,y) to the relation * Add (x,y) to the relation
* *