Add progress monitors.

Author: khatchad

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

@@ -21,6 +21,9 @@
 
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.dom.ASTVisitor;
 import org.eclipse.jdt.core.dom.IMethodBinding;
@@ -44,6 +47,7 @@
 import com.ibm.wala.util.scope.JUnitEntryPoints;
 
 import edu.cuny.hunter.streamrefactoring.core.analysis.StreamStateMachine.Statistics;
+import edu.cuny.hunter.streamrefactoring.core.messages.Messages;
 import edu.cuny.hunter.streamrefactoring.core.utils.LoggerNames;
 import edu.cuny.hunter.streamrefactoring.core.utils.TimeCollector;
 import edu.cuny.hunter.streamrefactoring.core.wala.EclipseProjectAnalysisEngine;
@@ -177,12 +181,15 @@ public StreamAnalyzer(boolean visitDocTags, int nForStreams, boolean findImplici
 
 	/**
 	 * Analyzes this {@link StreamAnalyzer}'s streams.
+	 * 
+	 * @param subMonitor
+	 * @param optional
 	 *
 	 * @return A {@link Map} of project's analyzed along with the entry points used.
 	 * @see #analyze(Optional).
 	 */
 	public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException {
-		return this.analyze(Optional.empty());
+		return this.analyze(Optional.empty(), new NullProgressMonitor());
 	}
 
 	/**
@@ -193,7 +200,10 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze() throws CoreException
 	 * @return A {@link Map} of project's analyzed along with the entry points used.
 	 * @see #analyze().
 	 */
-	public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector> collector) throws CoreException {
+	public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector> collector,
+			IProgressMonitor monitor) throws CoreException {
+		SubMonitor subMonitor = SubMonitor.convert(monitor, "Analyzing...", IProgressMonitor.UNKNOWN);
+
 		LOGGER.fine(() -> "Using N = " + this.getNForStreams() + ".");
 
 		Map<IJavaProject, Collection<Entrypoint>> ret = new HashMap<>();
@@ -203,6 +213,8 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 				.collect(Collectors.groupingBy(Stream::getCreationJavaProject, Collectors.toSet()));
 
 		// process each project.
+		subMonitor.beginTask("Processing projects ...", projectToStreams.keySet().size());
+
 		for (IJavaProject project : projectToStreams.keySet()) {
 			// create the analysis engine for the project.
 			// exclude from the analysis because the IR will be built here.
@@ -221,7 +233,8 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 			// build the call graph for the project.
 			Collection<Entrypoint> entryPoints = null;
 			try {
-				entryPoints = this.buildCallGraph(engine, collector);
+				entryPoints = this.buildCallGraph(engine, collector,
+						subMonitor.split(IProgressMonitor.UNKNOWN, SubMonitor.SUPPRESS_NONE));
 			} catch (IOException | CoreException | CancelException e) {
 				LOGGER.log(Level.SEVERE,
 						"Exception encountered while building call graph for: " + project.getElementName() + ".", e);
@@ -231,17 +244,21 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 			// save the entry points.
 			ret.put(project, entryPoints);
 
+			Set<Stream> streamSet = projectToStreams.get(project);
+
 			if (entryPoints.isEmpty()) {
 				// add a status entry for each stream in the project
-				for (Stream stream : projectToStreams.get(project))
+				for (Stream stream : streamSet)
 					stream.addStatusEntry(PreconditionFailure.NO_ENTRY_POINT,
 							"Project: " + engine.getProject().getElementName() + " has no entry points.");
 				return ret;
 			}
 
 			OrderingInference orderingInference = new OrderingInference(engine.getClassHierarchy());
 
-			for (Iterator<Stream> iterator = projectToStreams.get(project).iterator(); iterator.hasNext();) {
+			subMonitor.beginTask("Inferring initial stream attributes...", streamSet.size());
+
+			for (Iterator<Stream> iterator = streamSet.iterator(); iterator.hasNext();) {
 				Stream stream = iterator.next();
 				try {
 					stream.inferInitialAttributes(engine, orderingInference);
@@ -261,14 +278,16 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 					iterator.remove();
 					this.getStreamSet().remove(stream);
 				}
+				subMonitor.worked(1);
 			}
 
 			// start the state machine for each valid stream in the project.
 			StreamStateMachine stateMachine = new StreamStateMachine();
 			try {
-				Map<TypestateRule, StreamStateMachine.Statistics> ruleToStats = stateMachine.start(projectToStreams
-						.get(project).parallelStream().filter(s -> s.getStatus().isOK()).collect(Collectors.toSet()),
-						engine, orderingInference);
+				Map<TypestateRule, StreamStateMachine.Statistics> ruleToStats = stateMachine.start(
+						streamSet.parallelStream().filter(s -> s.getStatus().isOK()).collect(Collectors.toSet()),
+						engine, orderingInference,
+						subMonitor.split(IProgressMonitor.UNKNOWN, SubMonitor.SUPPRESS_NONE));
 
 				// use just one the rules.
 				assert !ruleToStats.isEmpty() : "Should have stats available.";
@@ -283,9 +302,16 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 			}
 
 			// check preconditions.
-			for (Stream stream : projectToStreams.get(project).parallelStream().filter(s -> s.getStatus().isOK())
-					.collect(Collectors.toSet()))
+			SubMonitor checkMonitor = subMonitor.split(IProgressMonitor.UNKNOWN, SubMonitor.SUPPRESS_NONE);
+			checkMonitor.beginTask(Messages.CheckingPreconditions, streamSet.size());
+
+			for (Stream stream : streamSet.parallelStream().filter(s -> s.getStatus().isOK())
+					.collect(Collectors.toSet())) {
 				stream.check();
+				checkMonitor.worked(1);
+			}
+
+			subMonitor.worked(1);
 		} // end for each stream.
 		return ret;
 	}
@@ -302,7 +328,7 @@ public Map<IJavaProject, Collection<Entrypoint>> analyze(Optional<TimeCollector>
 	 * @return The {@link Entrypoint}s used in building the {@link CallGraph}.
 	 */
 	protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<InstanceKey> engine,
-			Optional<TimeCollector> collector)
+			Optional<TimeCollector> collector, IProgressMonitor monitor)
 			throws IOException, CoreException, CallGraphBuilderCancelException, CancelException {
 		// if we haven't built the call graph yet.
 		if (!this.enginesWithBuiltCallGraphsToEntrypointsUsed.keySet().contains(engine)) {
@@ -373,7 +399,7 @@ protected Collection<Entrypoint> buildCallGraph(EclipseProjectAnalysisEngine<Ins
 			options.getSSAOptions().setPiNodePolicy(SSAOptions.getAllBuiltInPiNodes());
 
 			try {
-				engine.buildSafeCallGraph(options);
+				engine.buildSafeCallGraph(options, SubMonitor.convert(monitor, "Building call graph", 1));
 			} catch (IllegalStateException e) {
 				LOGGER.log(Level.SEVERE, e, () -> "Exception encountered while building call graph for project: "
 						+ engine.getProject().getElementName());

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

@@ -22,7 +22,8 @@
 import java.util.stream.Collectors;
 
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.jdt.core.JavaModelException;
 
 import com.google.common.collect.HashBasedTable;
@@ -567,8 +568,11 @@ private boolean deriveRomForNonScalarMethod(Collection<TypeAbstraction> possible
 	}
 
 	private void discoverIfReduceOrderingPossiblyMatters(EclipseProjectAnalysisEngine<InstanceKey> engine,
-			OrderingInference orderingInference) throws UTFDataFormatException, JavaModelException,
-			NoniterableException, NoninstantiableException, CannotExtractSpliteratorException {
+			OrderingInference orderingInference, IProgressMonitor monitor) throws UTFDataFormatException,
+			JavaModelException, NoniterableException, NoninstantiableException, CannotExtractSpliteratorException {
+		monitor.beginTask("Discovering if reduce order matters...",
+				this.terminalBlockToPossibleReceivers.keySet().size());
+
 		// for each terminal operation call, I think?
 		for (BasicBlockInContext<IExplodedBasicBlock> block : this.terminalBlockToPossibleReceivers.keySet()) {
 			int processedInstructions = 0;
@@ -648,6 +652,7 @@ private void discoverIfReduceOrderingPossiblyMatters(EclipseProjectAnalysisEngin
 				++processedInstructions;
 			}
 			assert processedInstructions == 1 : "Expecting to process one and only one instruction here.";
+			monitor.worked(1);
 		}
 	}
 
@@ -721,8 +726,10 @@ private void discoverLambdaSideEffects(EclipseProjectAnalysisEngine<InstanceKey>
 				LOGGER.warning("Def was an instance of a: " + def.getClass());
 	}
 
-	private void discoverPossibleSideEffects(EclipseProjectAnalysisEngine<InstanceKey> engine)
+	private void discoverPossibleSideEffects(EclipseProjectAnalysisEngine<InstanceKey> engine, IProgressMonitor monitor)
 			throws IOException, CoreException {
+		SubMonitor subMonitor = SubMonitor.convert(monitor, "Discovering side-effects...", 100);
+
 		// create the ModRef analysis.
 		ModRef<InstanceKey> modRef = ModRef.make();
 
@@ -732,6 +739,9 @@ private void discoverPossibleSideEffects(EclipseProjectAnalysisEngine<InstanceKe
 		Map<CGNode, OrdinalSet<PointerKey>> mod = modRef.computeMod(engine.getCallGraph(), engine.getPointerAnalysis());
 
 		// for each terminal operation call, I think?
+		SubMonitor loopMonitor = subMonitor.split(50, SubMonitor.SUPPRESS_NONE)
+				.setWorkRemaining(this.terminalBlockToPossibleReceivers.keySet().size());
+
 		for (BasicBlockInContext<IExplodedBasicBlock> block : this.terminalBlockToPossibleReceivers.keySet()) {
 			int processedInstructions = 0;
 			for (SSAInstruction instruction : block) {
@@ -760,10 +770,13 @@ private void discoverPossibleSideEffects(EclipseProjectAnalysisEngine<InstanceKe
 			}
 
 			assert processedInstructions == 1 : "Expecting to process one and only one instruction here.";
+			loopMonitor.worked(1);
 		}
 
 		// for each instance in the analysis result (these should be the
 		// "intermediate" streams).
+		loopMonitor = subMonitor.split(50, SubMonitor.SUPPRESS_NONE).setWorkRemaining(this.trackedInstances.size());
+
 		for (InstanceKey instance : this.trackedInstances) {
 			// make sure that the stream is the result of an intermediate
 			// operation.
@@ -792,14 +805,18 @@ private void discoverPossibleSideEffects(EclipseProjectAnalysisEngine<InstanceKe
 				this.discoverLambdaSideEffects(engine, mod, Collections.singleton(instance),
 						callString.getMethods()[0].getReference(), ir, use);
 			}
+
+			loopMonitor.worked(1);
 		}
 	}
 
-	private void discoverPossibleStatefulIntermediateOperations(IClassHierarchy hierarchy, CallGraph callGraph)
-			throws IOException, CoreException {
+	private void discoverPossibleStatefulIntermediateOperations(IClassHierarchy hierarchy, CallGraph callGraph,
+			IProgressMonitor monitor) throws IOException, CoreException {
+		monitor.beginTask("Discovering stateful intermediate operations...", this.trackedInstances.size());
+
 		// for each instance in the analysis result (these should be the
 		// "intermediate" streams).
-		for (InstanceKey instance : this.trackedInstances)
+		for (InstanceKey instance : this.trackedInstances) {
 			if (!this.instanceToStatefulIntermediateOperationContainment.containsKey(instance)) {
 				// make sure that the stream is the result of an intermediate
 				// operation.
@@ -816,21 +833,26 @@ private void discoverPossibleStatefulIntermediateOperations(IClassHierarchy hier
 					}
 				this.instanceToStatefulIntermediateOperationContainment.put(instance, found);
 			}
+			monitor.worked(1);
+		}
 	}
 
-	private void discoverTerminalOperations() {
+	private void discoverTerminalOperations(IProgressMonitor monitor) {
 		Collection<OrdinalSet<InstanceKey>> receiverSetsThatHaveTerminalOperations = this.terminalBlockToPossibleReceivers
 				.values();
 
 		// This will be the OK set.
 		Collection<InstanceKey> validStreams = new HashSet<>();
 
 		// Now, we need to flatten the receiver sets.
-		for (OrdinalSet<InstanceKey> receiverSet : receiverSetsThatHaveTerminalOperations)
+		monitor.beginTask("Flattening...", receiverSetsThatHaveTerminalOperations.size());
+		for (OrdinalSet<InstanceKey> receiverSet : receiverSetsThatHaveTerminalOperations) {
 			// for each receiver set
 			for (InstanceKey instance : receiverSet)
 				// add it to the OK set.
 				validStreams.add(instance);
+			monitor.worked(1);
+		}
 
 		// Now, we have the OK set. Let's propagate it.
 		this.propagateStreamInstanceProperty(validStreams);
@@ -864,8 +886,9 @@ private void fillInstanceToPredecessorMap(EclipseProjectAnalysisEngine<InstanceK
 		}
 	}
 
-	private void fillInstanceToStreamMap(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKey> engine)
-			throws InvalidClassFileException, IOException, CoreException {
+	private void fillInstanceToStreamMap(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKey> engine,
+			IProgressMonitor monitor) throws InvalidClassFileException, IOException, CoreException {
+		monitor.beginTask("Propagating...", streamSet.size());
 		int skippedStreams = 0;
 		for (Stream stream : streamSet) {
 			InstanceKey instanceKey = null;
@@ -904,6 +927,7 @@ private void fillInstanceToStreamMap(Set<Stream> streamSet, EclipseProjectAnalys
 				LOGGER.warning("Reassociating stream: " + stream.getCreation() + " with: " + instanceKey
 						+ ". Old stream was: " + oldValue.getCreation() + ".");
 
+			monitor.worked(1);
 		} // end each stream.
 
 		// sanity check since it's a bijection.
@@ -952,9 +976,10 @@ private void propagateStreamInstanceProperty(Collection<InstanceKey> streamInsta
 	}
 
 	public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjectAnalysisEngine<InstanceKey> engine,
-			OrderingInference orderingInference)
+			OrderingInference orderingInference, IProgressMonitor monitor)
 			throws PropertiesException, CancelException, IOException, CoreException, NoniterableException,
 			NoninstantiableException, CannotExtractSpliteratorException, InvalidClassFileException {
+		SubMonitor subMonitor = SubMonitor.convert(monitor, "Performing typestate analysis (may take a while)", 100);
 		Map<TypestateRule, Statistics> ret = new HashMap<>();
 
 		BenignOracle ora = new ModifiedBenignOracle(engine.getCallGraph(), engine.getPointerAnalysis());
@@ -973,6 +998,8 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 		StreamAttributeTypestateRule[] ruleArray = createStreamAttributeTypestateRules(streamClass);
 
 		// for each rule.
+		SubMonitor ruleMonitor = subMonitor.split(70, SubMonitor.SUPPRESS_NONE).setWorkRemaining(ruleArray.length);
+
 		for (StreamAttributeTypestateRule rule : ruleArray) {
 			// create a DFA based on the rule.
 			TypeStateProperty dfa = new TypeStateProperty(rule, engine.getClassHierarchy());
@@ -984,7 +1011,7 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 
 			AggregateSolverResult result;
 			try {
-				result = (AggregateSolverResult) solver.perform(new NullProgressMonitor());
+				result = (AggregateSolverResult) solver.perform(ruleMonitor.split(50, SubMonitor.SUPPRESS_NONE));
 			} catch (SolverTimeoutException | MaxFindingsException | SetUpException | WalaException e) {
 				throw new RuntimeException("Exception caught during typestate analysis.", e);
 			}
@@ -997,6 +1024,9 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 			assert lastStatistics == null : "Reassociating statistics.";
 
 			// for each instance in the typestate analysis result.
+			SubMonitor instanceMonitor = ruleMonitor.split(20, SubMonitor.SUPPRESS_NONE)
+					.setWorkRemaining(result.totalInstancesNum());
+
 			for (Iterator<InstanceKey> iterator = result.iterateInstances(); iterator.hasNext();) {
 				// get the instance's key.
 				InstanceKey instanceKey = iterator.next();
@@ -1140,6 +1170,7 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 							}
 						}
 					}
+				instanceMonitor.worked(1);
 			} // end for each instance in the typestate analysis result.
 
 			// fill the instance to predecessors map if it's empty.
@@ -1183,23 +1214,26 @@ public Map<TypestateRule, Statistics> start(Set<Stream> streamSet, EclipseProjec
 					});
 				}
 			}
+			ruleMonitor.worked(1);
 		} // end for each rule.
 
 		// create a mapping between stream instances (from the analysis) and stream
 		// objects (from the refactoring).
-		this.fillInstanceToStreamMap(streamSet, engine);
+		this.fillInstanceToStreamMap(streamSet, engine, subMonitor.split(5, SubMonitor.SUPPRESS_NONE));
 
-		this.discoverTerminalOperations();
+		this.discoverTerminalOperations(subMonitor.split(5, SubMonitor.SUPPRESS_NONE));
 
 		// fill the instance side-effect set.
-		this.discoverPossibleSideEffects(engine);
+		this.discoverPossibleSideEffects(engine, subMonitor.split(5, SubMonitor.SUPPRESS_NONE));
 
 		// discover whether any stateful intermediate operations are
 		// present.
-		this.discoverPossibleStatefulIntermediateOperations(engine.getClassHierarchy(), engine.getCallGraph());
+		this.discoverPossibleStatefulIntermediateOperations(engine.getClassHierarchy(), engine.getCallGraph(),
+				subMonitor.split(5, SubMonitor.SUPPRESS_NONE));
 
 		// does reduction order matter?
-		this.discoverIfReduceOrderingPossiblyMatters(engine, orderingInference);
+		this.discoverIfReduceOrderingPossiblyMatters(engine, orderingInference,
+				subMonitor.split(5, SubMonitor.SUPPRESS_NONE));
 
 		// propagate the instances with side-effects.
 		this.propagateStreamInstanceProperty(this.instancesWithSideEffects);