Better garbage collection

Previously each task had a reference to other tasks in its plan, causing
memory for all tasks to be held as long as a reference to one task was
strongly reachable. This change uses indirection to reduce the amount of
memory reachable: we uniquely identify each task in a plan and use this
for building relationships for trace purposes.

Author: cpettitt-linkedin

src/com/linkedin/parseq/BaseTask.java

@@ -23,6 +23,8 @@
 import com.linkedin.parseq.internal.SerialExecutor;
 import com.linkedin.parseq.internal.PlanContext;
 import com.linkedin.parseq.internal.TaskLogger;
+import com.linkedin.parseq.internal.trace.TraceCapturerImpl;
+import com.linkedin.parseq.internal.trace.TraceCapturer;
 import com.linkedin.parseq.promise.Promise;
 import com.linkedin.parseq.promise.PromiseListener;
 import org.slf4j.ILoggerFactory;
@@ -132,9 +134,12 @@ public void run(final Task<?> task)
 
     final long planId = NEXT_PLAN_ID.getAndIncrement();
     final Logger planLogger = _loggerFactory.getLogger(LOGGER_BASE + ":planClass=" + task.getClass().getName());
-    final TaskLogger taskLogger = new TaskLogger(task, _allLogger, _rootLogger, planLogger);
+    final TaskLogger taskLogger = new TaskLogger(planId, task, _allLogger, _rootLogger, planLogger);
+    final TraceCapturer traceCapturer = new TraceCapturerImpl(task);
+    final int taskId = traceCapturer.registerTask(task);
     final Executor taskExecutor = new SerialExecutor(_taskExecutor, new CancelPlanRejectionHandler(task));
-    new ContextImpl(new PlanContext(planId, this, taskExecutor, _timerExecutor, taskLogger), task).runTask();
+    final ContextImpl context = new ContextImpl(new PlanContext(planId, this, taskExecutor, _timerExecutor, traceCapturer, taskLogger), task, taskId);
+    context.runTask();
 
     InternalUtil.unwildcardTask(task).addListener(_taskDoneListener);
   }

src/com/linkedin/parseq/Engine.java

@@ -82,7 +82,7 @@ public void onResolved(Promise<Object> resolvedPromise)
         {
           if (task.isFailed())
           {
-            if (allEarlyFinish && ResultType.fromTask(task) != ResultType.EARLY_FINISH)
+            if (allEarlyFinish && task.getShallowTrace().getResultType() != ResultType.EARLY_FINISH)
             {
               allEarlyFinish = false;
             }

src/com/linkedin/parseq/ParTaskImpl.java

@@ -16,15 +16,11 @@
 
 package com.linkedin.parseq;
 
-import com.linkedin.parseq.internal.TaskLogger;
+import com.linkedin.parseq.internal.TaskListener;
 import com.linkedin.parseq.promise.Promise;
-import com.linkedin.parseq.trace.Related;
 import com.linkedin.parseq.trace.ShallowTrace;
 import com.linkedin.parseq.trace.Trace;
 
-import java.util.Collection;
-import java.util.Set;
-
 /**
  * A task represents a deferred execution that also contains its resulting
  * value. In addition, tasks include some tracing information that can be
@@ -38,11 +34,11 @@
 public interface Task<T> extends Promise<T>, Cancellable
 {
   /**
-   * Returns the name of this task.
-   *
-   * @return the name of this task
+   * Returns the name of this task. If no name was set during construction
+   * this method will return the value of {@link #toString()}. In most
+   * cases it is preferable to explicitly set a name.
    */
-  public String getName();
+  String getName();
 
   /**
    * Returns the priority for this task.
@@ -71,41 +67,38 @@ public interface Task<T> extends Promise<T>, Cancellable
   boolean setPriority(int priority);
 
   /**
-   * Attempts to run the task with the given context. This method is
-   * reserved for use by {@link Engine} and {@link Context}.
-   *
-   * @param context the context to use while running this step
-   * @param taskLogger the logger used for task events
-   * @param parent the parent of this task
-   * @param predecessors that lead to the execution of this task
-   */
-  void contextRun(Context context, TaskLogger taskLogger,
-                  Task<?> parent, Collection<Task<?>> predecessors);
-
-
-  /**
-   * Returns the ShallowTrace for this task. The ShallowTrace will be
-   * a point-in-time snapshot and may change over time until the task is
-   * completed.
-   *
-   * @return the ShallowTrace related to this task
+   * Returns a trace for this task alone. The trace is a point-in-time
+   * snapshot, so successive invocations of {@code getShallowTrace} may
+   * return different results.
    */
   ShallowTrace getShallowTrace();
 
   /**
-   * Returns the Trace for this task. The Trace will be a point-in-time snapshot
+   * Returns the trace for this task. The trace will be a point-in-time snapshot
    * and may change over time until the task is completed.
    *
-   * @return the Trace related to this task
+   * @return the trace related to this task
    */
   Trace getTrace();
 
   /**
-   * Returns the set of relationships of this task. The parent relationships are not included.
+   * Attempts to bind this task to the given context. A task may only be bound
+   * once. This method is reserved for use by the ParSeq framework only.
    *
-   * @see com.linkedin.parseq.trace.Relationship the available relationships
-   * @return the set of relationships of this task.
+   * @param context the context to assign to this task.
+   * @return {@code true} if the assignment was successful.
+   */
+  boolean assignContext(Context context);
+
+  /**
+   * Attempts to run the task with the given context. This method is for use by
+   * the ParSeq framework only.
    */
-  Set<Related<Task<?>>> getRelationships();
+  void contextRun();
 
+  /**
+   * Adds a listener to this task that is notified each time the task changes
+   * state. This method is for use by the ParSeq framework only.
+   */
+  void addTaskListener(TaskListener tracingTaskListener);
 }