Multi-stage progress infrastructure: first cut

gselzer · ctrueden · commit a9ed67a76d90 · 2022-04-13T11:46:52.000-05:00
diff --git a/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/progress/Progress.java b/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/progress/Progress.java
@@ -80,17 +80,20 @@ public static void update(long numElements) {
 		pingListeners();
 	}
 
-	public static void defineStages(long numStages) {
-		currentTask().defineStages(numStages);
+	public static void defineTotalProgress(int opStages) {
+		currentTask().defineTotalProgress(opStages);
+	}
+
+	public static void defineTotalProgress(int opStages, int totalSubTasks) {
+		currentTask().defineTotalProgress(opStages, totalSubTasks);
 	}
 
 	public static void registerSubtasks() {
 		
 	}
 
-	public static void maxForStage(long stage, long max) {
-		ProgressibleObject o = progressibleStack.get().peek();
-		o.task().setMax(max);
+	public static void setStageMax(long max) {
+		currentTask().setStageMax(max);
 	}
 
 	private Progress() {}
diff --git a/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/progress/Task.java b/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/progress/Task.java
@@ -6,7 +6,24 @@
 
 public class Task {
 
+	private final Task parent;
+
+	public Task() {
+		this.parent = null;
+	}
+
+	public Task(Task parent) {
+		this.parent = parent;
+	}
+
+	long numStages = -1;
+	AtomicLong stagesCompleted = new AtomicLong(0);
+
+	long numSubTasks = -1;
 	public List<Task> subTasks = new ArrayList<>();
+	AtomicLong subTasksCompleted = new AtomicLong(0);
+
+	boolean tasksDefined = false;
 
 	AtomicLong max = new AtomicLong(0);
 
@@ -15,38 +32,43 @@ public class Task {
 	public String status;
 
 	public synchronized Task createSubtask() {
-		Task sub = new Task();
+		Task sub = new Task(this);
 		subTasks.add(sub);
 		return sub;
 	}
 
 	
 	public void complete() {
 		current.set(max.get());
-		
+		if (parent != null) parent.recordSubtaskCompletion(this);
 	}
 
-	public void setMax(long max) {
-		this.max.set(max);
+	private void recordSubtaskCompletion(Task task) {
+		if (!subTasks.contains(task)) throw new IllegalArgumentException("Task " +
+			task + " is not a subtask of Task " + this);
+		subTasksCompleted.getAndIncrement();
+	}
+
+	public boolean isComplete() {
+		return max.get() == current.get() && subTasks.stream().allMatch(t -> t.isComplete());
 	}
 
+	public void defineTotalProgress(int opStages) {
+		defineTotalProgress(opStages, 0);
+	}
 
-	// TODO: If an Op tries to call Progress.update() without these variables
-	// being declared, throw an error!!!
-	public void defineStages(long numStages) {
-		
-		
+	public void defineTotalProgress(int opStages, int totalSubTasks) {
+		this.numStages = opStages;
+		this.numSubTasks = totalSubTasks;
+		this.tasksDefined = true;
 	}
 
-	// TODO: If an Op tries to call Progress.update() without these variables
-	// being declared, throw an error!!!
-	public void setSubTaskCount( long numSubTasks) {
-		
-		
+	public boolean progressDefined () {
+		return tasksDefined;
 	}
 
-	public void setCurrent(long current) {
-		this.current.set(current);
+	public void setStageMax(long max) {
+		this.max.set(max);
 	}
 
 	public void setStatus(String status) {
@@ -62,11 +84,16 @@ public long current( ) {
 	}
 
 	public double progress() {
-		return (double) current() / max();
+		if(!this.tasksDefined) throw new IllegalStateException("Progress undefined - Op does not define total progress");
+		double totalCompletion = stagesCompleted.get();
+		totalCompletion += current.doubleValue() / max.doubleValue();
+		totalCompletion += subTasksCompleted.get();
+		return totalCompletion / (numStages + numSubTasks);
 	}
 
 
 	public void update(long numElements) {
+		if(numStages == 0) throw new IllegalStateException("");
 		current.addAndGet(numElements);
 	}
 
diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/progress/DefaultProgressTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/progress/DefaultProgressTest.java
@@ -1,6 +1,7 @@
 
 package org.scijava.ops.engine.progress;
 
+import java.util.function.BiFunction;
 import java.util.function.Function;
 
 import org.junit.Assert;
@@ -16,17 +17,32 @@ public class DefaultProgressTest extends AbstractTestEnvironment {
 	@OpField(names = "test.progressReporter")
 	public final Function<Integer, Integer> iterator = (iterations) -> {
 		// set up progress reporter
-		Progress.defineStages(1);
-		Progress.maxForStage(0, iterations);
+		Progress.defineTotalProgress(1);
+		Progress.setStageMax(iterations);
 
-		for(int i = 0; i < iterations; i++) {
+		for (int i = 0; i < iterations; i++) {
 			Progress.update();
 		}
 		return iterations;
 	};
 
+	@OpField(names = "test.progressReporter")
+	public final BiFunction<Integer, Integer, Integer> doubleIterator = (
+		numStages, iterationsPerStage) -> {
+		// set up progress reporter
+		Progress.defineTotalProgress(numStages);
+		for (int j = 0; j < numStages; j++) {
+			Progress.setStageMax(iterationsPerStage);
+
+			for (int i = 0; i < iterationsPerStage; i++) {
+				Progress.update();
+			}
+		}
+		return numStages * iterationsPerStage;
+	};
+
 	@Test
-	public void testLongOp() throws InterruptedException {
+	public void testSimpleReporter() throws InterruptedException {
 		// obtain the Op
 		Function<Integer, Integer> op = //
 			ops.op("test.progressReporter") //
@@ -45,6 +61,27 @@ public void testLongOp() throws InterruptedException {
 
 	}
 
+	@Test
+	public void testMultiStageReporter() throws InterruptedException {
+		// obtain the Op
+		BiFunction<Integer,Integer, Integer> op = //
+			ops.op("test.progressReporter") //
+				.inType(Integer.class, Integer.class) //
+				.outType(Integer.class) //
+				.function();
+
+		int numIterations = 100;
+		int numStages = 10;
+		Progress.addListener(op, (t) -> {
+			testProgress(t.progress(), numStages * numIterations);
+		});
+		Thread t = new Thread(() -> op.apply(numStages, numIterations));
+		t.start();
+		t.join();
+		Assert.assertEquals(numStages * numIterations, this.numUpdates);
+
+	}
+
 	private int numUpdates = 0;
 
 	private void testProgress(double progress, int numIterations) {

Original file line number	Diff line number	Diff line change
`@@ -80,17 +80,20 @@ public static void update(long numElements) {`
`80`	`80`	`pingListeners();`
`81`	`81`	`}`
`82`	`82`
`83`		`- public static void defineStages(long numStages) {`
`84`		`- currentTask().defineStages(numStages);`
	`83`	`+ public static void defineTotalProgress(int opStages) {`
	`84`	`+ currentTask().defineTotalProgress(opStages);`
	`85`	`+ }`
	`86`	`+`
	`87`	`+ public static void defineTotalProgress(int opStages, int totalSubTasks) {`
	`88`	`+ currentTask().defineTotalProgress(opStages, totalSubTasks);`
`85`	`89`	`}`
`86`	`90`
`87`	`91`	`public static void registerSubtasks() {`
`88`	`92`
`89`	`93`	`}`
`90`	`94`
`91`		`- public static void maxForStage(long stage, long max) {`
`92`		`- ProgressibleObject o = progressibleStack.get().peek();`
`93`		`- o.task().setMax(max);`
	`95`	`+ public static void setStageMax(long max) {`
	`96`	`+ currentTask().setStageMax(max);`
`94`	`97`	`}`
`95`	`98`
`96`	`99`	`private Progress() {}`