TaskScheduler [5/9] Task Tracker

base/task_scheduler/task_tracker.h

Index: base/task_scheduler/task_tracker.h
diff --git a/base/task_scheduler/task_tracker.h b/base/task_scheduler/task_tracker.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a889d7b22a6a4fbbd638dd773301d70be839915
--- /dev/null
+++ b/base/task_scheduler/task_tracker.h
@@ -0,0 +1,94 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TASK_SCHEDULER_TASK_TRACKER_H_
+#define BASE_TASK_SCHEDULER_TASK_TRACKER_H_
+
+#include "base/base_export.h"
+#include "base/callback_forward.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/synchronization/condition_variable.h"
+#include "base/task_scheduler/scheduler_lock.h"
+#include "base/task_scheduler/task.h"
+#include "base/task_scheduler/task_traits.h"
+
+namespace base {
+namespace internal {
+
+// All tasks go through the scheduler's TaskTracker when they are posted and
+// when they are executed. The TaskTracker enforces shutdown semantics and takes
+// care of tracing and profiling. This class is thread-safe.
+class BASE_EXPORT TaskTracker {
+ public:
+  TaskTracker();
+  ~TaskTracker();
+
+  // Synchronously shuts down the scheduler. Once this is called, only tasks
+  // posted with the BLOCK_SHUTDOWN behavior will be run. Returns when:
+  // - All SKIP_ON_SHUTDOWN tasks that were already running have completed their
+  //   execution.
+  // - All posted BLOCK_SHUTDOWN tasks have completed their execution.
+  // This must only be called once.
+  void Shutdown();
+
+  // Posts |task| by calling |post_task_callback| unless the current shutdown
+  // state prevents that. A task forwarded to |post_task_callback| must be
+  // handed back to this instance's RunTask() when it is to be executed.
+  void PostTask(const Callback<void(scoped_ptr<Task>)>& post_task_callback,

[danakj, 2016/03/22 18:56:56]

Can you explain the rationale for using a Callback for this? Do many different
places end up calling PostTask and it needs to call back to all of them?

If it's always one object, we could use a TaskTrackerClient that you set on
create, and it can just call a method on the client? That's cheaper than
constructing Callbacks each time.

[fdoray, 2016/03/22 20:19:43]

The callback will always be bound to the same function, but with different
arguments depending on the pq and sequence in which we want to insert the task.
E.g. Bind(&PostTaskHelper, Unretained(priority_queue), sequence)

I'm in favor of changing TaskTracker::PostTask to take pq+sequence as arguments
instead of a callback. The "post task" algorithm that we planned to put in
PostTaskHelper() would be in TaskTracker instead. It would be cheaper + it would
allow us to provide info about the sequence and pq to tracing.

I think that the reason why we decided to have a callback was to decouple
TaskTracker from PriorityQueue and Sequence.

WDYT?

[gab, 2016/03/24 14:50:12]

For the sake of encapsulation, I'd like to avoid making TaskTracker aware of
PriorityQueue and Sequence.

|post_task_callback| is merely a continuation (in fact I'd prefer
|post_task_continuation| as a name now that I think about it)

This can't be a raw function pointer or a method on a constant delegate because
it binds PQ and Sequence :-(.

This isn't done in a loop and is only done on PostTask, i.e. in situations where
someone already called Bind on the real task. So is the overhead of an extra
Bind really a concern?
We could make this method aware of the logic in PostTaskHelper, but it feels out
of place to me...

[robliao, 2016/03/24 15:46:03]

The root of the issue stems from a necessity to synchronize between if we should
post the task and actually posting the task, particularly during shutdown
scenarios.

The code is roughly:
if (CanPostTask(task)) { // We're good to post the task if we aren't yet
shutting down
  UpdateAccounting(task); // Track if this task blocks shutdown
  PostTask(task); 
}

If we shutdown between CanPostTask and UpdateAccounting on a BLOCK_ON_SHUTDOWN
task, shutdown will immediately happen (since we haven't yet accounted for the
task), and then we'll post the task.

Now we have a BLOCK_ON_SHUTDOWN task after we've shut down. Very bad.

To address this, the CanPostTask and UpdateAccounting are synchronized in
BeforeRunTask. The callback simply allows us to abstract away the details of
posting the task from the TaskTracker as the TaskTracker's job is to simply
perform accounting.



The second approach would be to create a transactional object (similar to
PriorityQueue) and expose things like CanPostTask (The check) and OnPostTask
(The accounting). We felt that having this would unnecessarily complicate the
design for this one-off need for synchronicity. 



Having said that, the TaskTracker should be unaware of the existence of a
PriorityQueue and a Sequence as they are implementation details of posting a
task.

+                scoped_ptr<Task> task);
+
+  // Runs |task| unless the current shutdown state prevents that. |task| must
+  // have been successfully posted via PostTask() first.
+  void RunTask(const Task* task);
+
+  // Returns true while shutdown is in progress (i.e. Shutdown() has been called
+  // but hasn't returned).
+  bool IsShuttingDownForTesting() const;
+
+  bool shutdown_completed() const {
+    AutoSchedulerLock auto_lock(lock_);
+    return shutdown_completed_;
+  }
+
+ private:
+  // Called before a task with |shutdown_behavior| is handed off to
+  // |post_task_callback| by PostTask(). Updates |num_tasks_blocking_shutdown_|
+  // if necessary and returns true if the current shutdown state allows the task
+  // to be posted.
+  bool BeforePostTask(TaskShutdownBehavior shutdown_behavior);
+
+  // Called before a task with |shutdown_behavior| is run by RunTask(). Updates
+  // |num_tasks_blocking_shutdown_| if necessary and returns true if the current
+  // shutdown state allows the task to be run.
+  bool BeforeRunTask(TaskShutdownBehavior shutdown_behavior);
+
+  // Called after a task with |shutdown_behavior| has been run by RunTask().
+  // Updates |num_tasks_blocking_shutdown_| and signals |shutdown_cv_| if
+  // necessary.
+  void AfterRunTask(TaskShutdownBehavior shutdown_behavior);
+
+  // Synchronizes access to all members.
+  mutable SchedulerLock lock_;
+
+  // Condition variable signaled when |num_tasks_blocking_shutdown_| reaches
+  // zero while shutdown is in progress. Null if shutdown isn't in progress.
+  scoped_ptr<ConditionVariable> shutdown_cv_;
+
+  // Number of tasks blocking shutdown.
+  size_t num_tasks_blocking_shutdown_ = 0;
+
+  // Number of BLOCK_SHUTDOWN tasks posted during shutdown.
+  size_t num_block_shutdown_tasks_posted_during_shutdown_ = 0;
+
+  // True once Shutdown() has returned. No new task can be scheduled after this.
+  bool shutdown_completed_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskTracker);
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_TASK_SCHEDULER_TASK_TRACKER_H_