Add statistics for stream instances during typestate analysis.

Author: khatchad

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/StreamAnalyzer.java

@@ -29,6 +29,7 @@
 import org.eclipse.jdt.internal.corext.util.JdtFlags;
 
 import com.ibm.safe.internal.exceptions.PropertiesException;
+import com.ibm.safe.rules.TypestateRule;
 import com.ibm.wala.ipa.callgraph.AnalysisOptions;
 import com.ibm.wala.ipa.callgraph.AnalysisOptions.ReflectionOptions;
 import com.ibm.wala.ipa.callgraph.CallGraph;
@@ -42,6 +43,7 @@
 import com.ibm.wala.util.CancelException;
 import com.ibm.wala.util.scope.JUnitEntryPoints;
 
+import edu.cuny.hunter.streamrefactoring.core.analysis.StreamStateMachine.Statistics;
 import edu.cuny.hunter.streamrefactoring.core.utils.LoggerNames;
 import edu.cuny.hunter.streamrefactoring.core.utils.TimeCollector;
 import edu.cuny.hunter.streamrefactoring.core.wala.EclipseProjectAnalysisEngine;
@@ -81,6 +83,10 @@ private static void addImplicitEntryPoints(Collection<Entrypoint> target, Iterab
 	 */
 	private int nForStreams = N_FOR_STREAMS_DEFAULT;
 
+	private int numberOfProcessedStreamInstances;
+
+	private int numberOfSkippedStreamInstances;
+
 	public StreamAnalyzer() {
 		this(false);
 	}
@@ -208,8 +214,16 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 			// start the state machine for each valid stream in the project.
 			StreamStateMachine stateMachine = new StreamStateMachine();
 			try {
-				stateMachine.start(projectToStreams.get(project).parallelStream().filter(s -> s.getStatus().isOK())
-						.collect(Collectors.toSet()), engine, orderingInference);
+				Map<TypestateRule, StreamStateMachine.Statistics> ruleToStats = stateMachine.start(projectToStreams
+						.get(project).parallelStream().filter(s -> s.getStatus().isOK()).collect(Collectors.toSet()),
+						engine, orderingInference);
+
+				// use just one the rules.
+				assert !ruleToStats.isEmpty() : "Should have stats available.";
+				Statistics statistics = ruleToStats.values().iterator().next();
+
+				this.setNumberOfProcessedStreamInstances(statistics.getNumberOfStreamInstancesProcessed());
+				this.setNumberOfSkippedStreamInstances(statistics.getNumberOfStreamInstancesSkipped());
 			} catch (PropertiesException | CancelException | NoniterableException | NoninstantiableException
 					| CannotExtractSpliteratorException | InvalidClassFileException | IOException e) {
 				LOGGER.log(Level.SEVERE, "Error while starting state machine.", e);
@@ -221,7 +235,6 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 					.collect(Collectors.toSet()))
 				stream.check();
 		} // end for each stream.
-
 		return ret;
 	}
 
@@ -435,4 +448,20 @@ public int getNForStreams() {
 	protected void setNForStreams(int nForStreams) {
 		this.nForStreams = nForStreams;
 	}
+
+	public int getNumberOfProcessedStreamInstances() {
+		return this.numberOfProcessedStreamInstances;
+	}
+
+	protected void setNumberOfProcessedStreamInstances(int numberOfProcessedStreamInstances) {
+		this.numberOfProcessedStreamInstances = numberOfProcessedStreamInstances;
+	}
+
+	public int getNumberOfSkippedStreamInstances() {
+		return this.numberOfSkippedStreamInstances;
+	}
+
+	protected void setNumberOfSkippedStreamInstances(int numberOfSkippedStreamInstances) {
+		this.numberOfSkippedStreamInstances = numberOfSkippedStreamInstances;
+	}
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/StreamStateMachine.java

@@ -81,6 +81,7 @@
 import com.ibm.wala.util.intset.OrdinalSet;
 import com.ibm.wala.util.strings.Atom;
 
+import edu.cuny.hunter.streamrefactoring.core.analysis.StreamStateMachine.Statistics;
 import edu.cuny.hunter.streamrefactoring.core.safe.ModifiedBenignOracle;
 import edu.cuny.hunter.streamrefactoring.core.safe.NoApplicationCodeExistsInCallStringsException;
 import edu.cuny.hunter.streamrefactoring.core.safe.TypestateSolverFactory;
@@ -90,6 +91,25 @@
 
 public class StreamStateMachine {
 
+	public class Statistics {
+		private int numberOfStreamInstancesProcessed;
+		private int numberOfStreamInstancesSkipped;
+
+		public Statistics(int numberOfStreamInstancesProcessed, int numberOfStreamInstancesSkipped) {
+			this.numberOfStreamInstancesProcessed = numberOfStreamInstancesProcessed;
+			this.numberOfStreamInstancesSkipped = numberOfStreamInstancesSkipped;
+		}
+
+		public int getNumberOfStreamInstancesProcessed() {
+			return numberOfStreamInstancesProcessed;
+		}
+
+		public int getNumberOfStreamInstancesSkipped() {
+			return numberOfStreamInstancesSkipped;
+		}
+	}
+
+	@SuppressWarnings("unused")
 	private static final String ARRAYS_STREAM_CREATION_METHOD_NAME = "Arrays.stream";
 
 	private static final Logger LOGGER = Logger.getLogger(LoggerNames.LOGGER_NAME);
@@ -926,10 +946,12 @@ private void propagateStreamInstanceProperty(Collection<InstanceKey> streamInsta
 				.flatMap(ik -> this.getAllPredecessors(ik).stream()).collect(Collectors.toSet()));
 	}
 
-	public void start(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKey> engine,
+	public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKey> engine,
 			OrderingInference orderingInference)
 			throws PropertiesException, CancelException, IOException, CoreException, NoniterableException,
 			NoninstantiableException, CannotExtractSpliteratorException, InvalidClassFileException {
+		Map<TypestateRule, Statistics> ret = new HashMap<>();
+		
 		BenignOracle ora = new ModifiedBenignOracle(engine.getCallGraph(), engine.getPointerAnalysis());
 
 		PropertiesManager manager = PropertiesManager.initFromMap(Collections.emptyMap());
@@ -962,6 +984,11 @@ public void start(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKe
 				throw new RuntimeException("Exception caught during typestate analysis.", e);
 			}
 
+			// record statistics.
+			Statistics lastStatistics = ret.put(rule,
+					new Statistics(result.processedInstancesNum(), result.skippedInstances()));
+			assert lastStatistics == null : "Reassociating statistics.";
+
 			// for each instance in the typestate analysis result.
 			for (Iterator<InstanceKey> iterator = result.iterateInstances(); iterator.hasNext();) {
 				// get the instance's key.
@@ -1220,5 +1247,6 @@ public void start(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKe
 						this.instancesWhoseReduceOrderingPossiblyMatters.contains(streamInstanceKey));
 			}
 		}
+		return ret;
 	}
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/refactorings/ConvertToParallelStreamRefactoringProcessor.java

@@ -146,6 +146,10 @@ public static void setLoggingLevel(int level) {
 
 	private int nForStreams = N_FOR_STREAMS_DEFAULT;
 
+	private int numberOfProcessedStreamInstances;
+
+	private int numberOfSkippedStreamInstances;
+
 	public ConvertToParallelStreamRefactoringProcessor() throws JavaModelException {
 		this(null, null, false, true, false, false, Optional.empty());
 	}
@@ -242,6 +246,10 @@ public RefactoringStatus checkFinalConditions(final IProgressMonitor monitor, fi
 			// analyze and set entry points.
 			this.projectToEntryPoints = analyzer.analyze(Optional.of(this.getExcludedTimeCollector()));
 
+			// set statistics for stream instances.
+			this.setNumberOfProcessedStreamInstances(analyzer.getNumberOfProcessedStreamInstances());
+			this.setNumberOfSkippedStreamInstances(analyzer.getNumberOfSkippedStreamInstances());
+
 			// map empty set to unprocessed projects.
 			for (IJavaProject project : this.getJavaProjects())
 				this.projectToEntryPoints.computeIfAbsent(project, p -> Collections.emptySet());
@@ -530,4 +538,20 @@ private void manageCompilationUnit(final TextEditBasedChangeManager manager, Com
 	protected void setStreamSet(Set<Stream> streamSet) {
 		this.streamSet = streamSet;
 	}
+
+	public int getNumberOfProcessedStreamInstances() {
+		return this.numberOfProcessedStreamInstances;
+	}
+
+	protected void setNumberOfProcessedStreamInstances(int numberOfProcessedStreamInstances) {
+		this.numberOfProcessedStreamInstances = numberOfProcessedStreamInstances;
+	}
+
+	public int getNumberOfSkippedStreamInstances() {
+		return this.numberOfSkippedStreamInstances;
+	}
+
+	protected void setNumberOfSkippedStreamInstances(int numberOfSkippedStreamInstances) {
+		this.numberOfSkippedStreamInstances = numberOfSkippedStreamInstances;
+	}
 }

edu.cuny.hunter.streamrefactoring.eval/src/edu/cuny/hunter/streamrefactoring/eval/handlers/EvaluateConvertToParallelStreamRefactoringHandler.java

@@ -207,9 +207,9 @@ public Object execute(ExecutionEvent event) throws ExecutionException {
 
 				IJavaProject[] javaProjects = Util.getSelectedJavaProjectsFromEvent(event);
 
-				List<String> resultsHeader = new ArrayList<>(
-						Arrays.asList("subject", "SLOC", "#entrypoints", "N", "#streams",
-								"#optimization available streams", "#optimizable streams", "#failed preconditions"));
+				List<String> resultsHeader = new ArrayList<>(Arrays.asList("subject", "SLOC", "#entrypoints", "N",
+						"#streams", "#optimization available streams", "#optimizable streams", "#failed preconditions",
+						"stream instances processed", "stream instances skipped"));
 
 				for (Refactoring refactoring : Refactoring.values())
 					resultsHeader.add(refactoring.toString());
@@ -402,6 +402,12 @@ public Object execute(ExecutionEvent event) throws ExecutionException {
 									entry.getCode(), entry.getMessage());
 						}
 
+					// #stream instances analyzed.
+					resultsPrinter.print(processor.getNumberOfProcessedStreamInstances());
+
+					// #stream instances skipped.
+					resultsPrinter.print(processor.getNumberOfSkippedStreamInstances());
+
 					// Refactoring type counts.
 					for (Refactoring refactoring : Refactoring.values())
 						resultsPrinter.print(processor.getStreamSet().parallelStream().map(Stream::getRefactoring)