[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.h

 // Copyright 2017 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 THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_BUDGET_POOL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_BUDGET_POOL_H_
 
 #include <unordered_set>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "platform/scheduler/base/lazy_now.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace blink {
 namespace scheduler {
 
 class TaskQueue;
 class BudgetPoolController;
+enum class QueueBlockType;
 
 // BudgetPool represents a group of task queues which share a limit
 // on a resource. This limit applies when task queues are already throttled
 // by TaskQueueThrottler.
 class BLINK_PLATFORM_EXPORT BudgetPool {
  public:
   virtual ~BudgetPool();
 
   const char* Name() const;
 
   // Report task run time to the budget pool.
-  virtual void RecordTaskRunTime(base::TimeTicks start_time,
+  virtual void RecordTaskRunTime(TaskQueue* queue,
+                                 base::TimeTicks start_time,
                                  base::TimeTicks end_time) = 0;
 
-  // Retuns earliest time (can be in the past) when the next task can run.
-  virtual base::TimeTicks GetNextAllowedRunTime() = 0;
+  // Returns earliest time when the next pump can be scheduled to run new tasks.

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

Returns the earliest...

[altimin, 2017/04/25 13:22:35]

Done.

+  virtual base::TimeTicks GetNextAllowedRunTime(
+      base::TimeTicks desired_run_time) const = 0;
 
   // Returns true at a task can be run immediately at the given time.
-  virtual bool HasEnoughBudgetToRun(base::TimeTicks now) = 0;
+  virtual bool CanRunTasksAt(base::TimeTicks moment) const = 0;
+
+  // Returns true if tasks can run at any time up to |moment|.
+  virtual bool CanRunTasksUntil(base::TimeTicks now,
+                                base::TimeTicks moment) const = 0;
+
+  // Notifies budget pool that queue has work with desired run time.
+  virtual void OnTaskQueueHasWork(TaskQueue* queue,
+                                  base::TimeTicks now,
+                                  base::TimeTicks desired_run_time) = 0;
+
+  // Notifies budget pool that wakeup has happened.
+  virtual void OnWakeup(base::TimeTicks now) = 0;
 
   // Returns state for tracing.
   virtual void AsValueInto(base::trace_event::TracedValue* state,
                            base::TimeTicks now) const = 0;
 
   // Adds |queue| to given pool. If the pool restriction does not allow
   // a task to be run immediately and |queue| is throttled, |queue| becomes
   // disabled.
   void AddQueue(base::TimeTicks now, TaskQueue* queue);
 
   // Removes |queue| from given pool. If it is throttled, it does not
   // become enabled immediately, but a call to |PumpThrottledTasks|
   // is scheduled.

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

Maybe comment this schedules a wake up if needed.

[altimin, 2017/04/25 13:22:35]

Done.

   void RemoveQueue(base::TimeTicks now, TaskQueue* queue);
 
+  // Unlike RemoveQueue, does not schedule a new wakeup for the queue.
+  void UnregisterQueue(TaskQueue* queue);
+
   // Enables this time budget pool. Queues from this pool will be
   // throttled based on their run time.
   void EnableThrottling(LazyNow* now);
 
   // Disables with time budget pool. Queues from this pool will not be
   // throttled based on their run time. A call to |PumpThrottledTasks|
   // will be scheduled to enable this queues back again and respect
   // timer alignment. Internal budget level will not regenerate with time.
   void DisableThrottling(LazyNow* now);
 
   bool IsThrottlingEnabled() const;
 
   // All queues should be removed before calling Close().
   void Close();
 
   // Block all associated queues and schedule them to run when appropriate.
   void BlockThrottledQueues(base::TimeTicks now);
 
  protected:
   BudgetPool(const char* name, BudgetPoolController* budget_pool_controller);
 
+  // Specify how this budget pool should block affected queues.
+  virtual QueueBlockType GetBlockType() const = 0;
+
   const char* name_;  // NOT OWNED
 
   BudgetPoolController* budget_pool_controller_;
 
   std::unordered_set<TaskQueue*> associated_task_queues_;
   bool is_enabled_;
 };
 
 // CPUTimeBudgetPool represents a collection of task queues which share a limit
 // on total cpu time.
@@ skipping 42 matching lines @@
   // queues even if they are allowed to run with increased budget level.
   void GrantAdditionalBudget(base::TimeTicks now, base::TimeDelta budget_level);
 
   // Set callback which will be called every time when this budget pool
   // is throttled. Throttling duration (time until the queue is allowed
   // to run again) is passed as a parameter to callback.
   void SetReportingCallback(
       base::Callback<void(base::TimeDelta)> reporting_callback);
 
   // BudgetPool implementation:
-  void RecordTaskRunTime(base::TimeTicks start_time,
+  void RecordTaskRunTime(TaskQueue* queue,
+                         base::TimeTicks start_time,
                          base::TimeTicks end_time) final;
-  bool HasEnoughBudgetToRun(base::TimeTicks now) final;
-  base::TimeTicks GetNextAllowedRunTime() final;
+  bool CanRunTasksUntil(base::TimeTicks now, base::TimeTicks until) const final;
+  bool CanRunTasksAt(base::TimeTicks now) const final;
+  base::TimeTicks GetNextAllowedRunTime(
+      base::TimeTicks desired_run_time) const final;
+  void OnTaskQueueHasWork(TaskQueue* queue,
+                          base::TimeTicks now,
+                          base::TimeTicks desired_run_time) final;
+  void OnWakeup(base::TimeTicks now) final;
   void AsValueInto(base::trace_event::TracedValue* state,
                    base::TimeTicks now) const final;
 
+ protected:
+  QueueBlockType GetBlockType() const final;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(TaskQueueThrottlerTest, CPUTimeBudgetPool);
 
   // Advances |last_checkpoint_| to |now| if needed and recalculates
   // budget level.
   void Advance(base::TimeTicks now);
 
   // Increase |current_budget_level_| to satisfy max throttling duration
   // condition if necessary.
   // Decrease |current_budget_level_| to satisfy max budget level
@@ skipping 15 matching lines @@
 
   base::TimeDelta current_budget_level_;
   base::TimeTicks last_checkpoint_;
   double cpu_percentage_;
 
   base::Callback<void(base::TimeDelta)> reporting_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CPUTimeBudgetPool);
 };
 
+// WakeupBudgetPool represents a collection of task queues which share a limit
+// on total cpu time.
+class BLINK_PLATFORM_EXPORT WakeupBudgetPool : public BudgetPool {

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

I think we should try to keep to 1 major class per .cc / .h file (I know we
don't always do that, but files end up getting very long otherwise).

[altimin, 2017/04/25 13:22:35]

I was thinking that these classes are too similar and share a lot of code (in
BudgetPool), so it makes sense to keep them here for now (but if we were to add
one more budget pool here, I'd agree that we had to separate them). 

[alex clarke (OOO till 29th), 2017/04/27 10:28:14]

Sorry to be a pain but I think we should separate this.  Smaller files are good.

[altimin, 2017/04/27 11:07:40]

Done.

+ public:
+  WakeupBudgetPool(const char* name,
+                   BudgetPoolController* budget_pool_controller,
+                   base::TimeTicks now);
+  ~WakeupBudgetPool();

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

override?

[altimin, 2017/04/25 13:22:35]

Done.

+
+  void SetWakeupRate(base::TimeTicks now, double wakeups_per_second);

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

Why do we need to pass |now| into this?  I notice that there is a call to:
GetMainThreadOnly().wake_up_budget_pool->SetWakeupRate(base::TimeTicks(), 1);

I notice there already is OnWakeup(base::TimeTicks now)

[altimin, 2017/04/25 13:22:35]

Done.

+
+  void SetWakeupDuration(base::TimeTicks now, base::TimeDelta duration);

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

Same question.

[altimin, 2017/04/25 13:22:35]

Done.

+
+  // BudgetPool implementation:
+  void RecordTaskRunTime(TaskQueue* queue,
+                         base::TimeTicks start_time,
+                         base::TimeTicks end_time) final;
+  bool CanRunTasksUntil(base::TimeTicks now,
+                        base::TimeTicks moment) const final;
+  bool CanRunTasksAt(base::TimeTicks now) const final;
+  base::TimeTicks GetNextAllowedRunTime(
+      base::TimeTicks desired_run_time) const final;
+  void OnTaskQueueHasWork(TaskQueue* queue,
+                          base::TimeTicks now,
+                          base::TimeTicks desired_run_time) final;
+  void OnWakeup(base::TimeTicks now) final;
+  void AsValueInto(base::trace_event::TracedValue* state,
+                   base::TimeTicks now) const final;
+
+ protected:
+  QueueBlockType GetBlockType() const final;
+
+ private:
+  base::TimeTicks NextWakeup() const;
+
+  double wakeups_per_second_;
+  base::TimeDelta wakeup_duration_;
+
+  base::TimeTicks last_wakeup_;
+
+  DISALLOW_COPY_AND_ASSIGN(WakeupBudgetPool);
+};
+
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_BUDGET_POOL_H_