power_mode_arbiter.h 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef COMPONENTS_POWER_SCHEDULER_POWER_MODE_ARBITER_H_
  5. #define COMPONENTS_POWER_SCHEDULER_POWER_MODE_ARBITER_H_
  6. #include <map>
  7. #include <memory>
  8. #include "base/component_export.h"
  9. #include "base/gtest_prod_util.h"
  10. #include "base/memory/scoped_refptr.h"
  11. #include "base/observer_list_threadsafe.h"
  12. #include "base/synchronization/lock.h"
  13. #include "base/task/task_runner.h"
  14. #include "base/thread_annotations.h"
  15. #include "base/time/time.h"
  16. #include "base/trace_event/trace_log.h"
  17. #include "components/power_scheduler/power_mode.h"
  18. #include "components/power_scheduler/power_mode_voter.h"
  19. #include "components/power_scheduler/traced_power_mode.h"
  20. namespace power_scheduler {
  21. // Decides the active PowerMode for a process. To do this, it collects votes
  22. // from various instrumentation points in Chromium.
  23. //
  24. // Each instrumentation point can instantiate a PowerModeVoter and submit votes:
  25. // auto voter = PowerModeArbiter::GetInstance()->NewVoter("MyVoter");
  26. // voter->VoteFor(PowerMode::kCharging);
  27. //
  28. // The active PowerMode is decided via a prioritization mechanism, see
  29. // ComputeActiveModeLocked().
  30. class COMPONENT_EXPORT(POWER_SCHEDULER) PowerModeArbiter
  31. : public base::trace_event::TraceLog::EnabledStateObserver,
  32. public base::trace_event::TraceLog::IncrementalStateObserver,
  33. public PowerModeVoter::Delegate {
  34. public:
  35. class COMPONENT_EXPORT(POWER_SCHEDULER) Observer {
  36. public:
  37. virtual ~Observer();
  38. virtual void OnPowerModeChanged(PowerMode old_mode, PowerMode new_mode) = 0;
  39. };
  40. // Limits the frequency at which we can run the UpdatePendingResets() task.
  41. // All pending resets are aligned to this time resolution. Public for testing.
  42. static constexpr base::TimeDelta kResetVoteTimeResolution =
  43. base::Milliseconds(100);
  44. static PowerModeArbiter* GetInstance();
  45. // Public for testing.
  46. PowerModeArbiter();
  47. ~PowerModeArbiter() override;
  48. PowerModeArbiter(const PowerModeArbiter&) = delete;
  49. PowerModeArbiter& operator=(const PowerModeArbiter&) = delete;
  50. // Instantiates a new Voter for an instrumentation site. |name| must be a
  51. // static string and is used for tracing instrumentation.
  52. std::unique_ptr<PowerModeVoter> NewVoter(const char* name);
  53. // Adds/removes an observer that is notified for every change of the
  54. // process-wide mode. The observer is notified on the task sequence it
  55. // registered on.
  56. void AddObserver(Observer*);
  57. void RemoveObserver(Observer*);
  58. // Should be called by the embedder during process startup, once the thread
  59. // pool is available.
  60. void OnThreadPoolAvailable();
  61. // Enables or disables the kCharging PowerMode. Defaults to enabled, i.e.
  62. // kCharging will preempt all other PowerModes while the device is on a
  63. // charger.
  64. void SetChargingModeEnabled(bool enabled);
  65. // Provide a custom task runner for unit tests. Replaces a call to
  66. // OnThreadPoolAvailable().
  67. void SetTaskRunnerForTesting(scoped_refptr<base::SequencedTaskRunner>);
  68. PowerMode GetActiveModeForTesting();
  69. // TODO(eseckler): Replace this with SetChargingModeEnabled() in tests.
  70. void SetOnBatteryPowerForTesting(bool on_battery_power);
  71. private:
  72. FRIEND_TEST_ALL_PREFIXES(PowerModeArbiterTest, ObserverEnablesResetTasks);
  73. class ChargingPowerModeVoter;
  74. // PowerModeVoter::Delegate implementation:
  75. void OnVoterDestroyed(PowerModeVoter*) override;
  76. void SetVote(PowerModeVoter*, PowerMode) override;
  77. void ResetVoteAfterTimeout(PowerModeVoter*, base::TimeDelta timeout) override;
  78. void OnTaskRunnerAvailable(scoped_refptr<base::SequencedTaskRunner>,
  79. int sequence_number);
  80. void UpdatePendingResets(int sequence_number);
  81. void OnVotesUpdated();
  82. void ServicePendingResetsLocked() EXCLUSIVE_LOCKS_REQUIRED(lock_);
  83. PowerMode ComputeActiveModeLocked() EXCLUSIVE_LOCKS_REQUIRED(lock_);
  84. void UpdateTraceObserver() LOCKS_EXCLUDED(lock_, trace_observer_lock_);
  85. // trace_event::TraceLog::EnabledStateObserver implementation:
  86. void OnTraceLogEnabled() override;
  87. void OnTraceLogDisabled() override;
  88. // trace_event::TraceLog::IncrementalStateObserver implementation:
  89. void OnIncrementalStateCleared() override;
  90. // Protects trace_observer_{,added_}. Should only be acquired when |lock_| is
  91. // not held.
  92. base::Lock trace_observer_lock_;
  93. std::unique_ptr<Observer> trace_observer_ GUARDED_BY(trace_observer_lock_);
  94. bool trace_observer_added_ GUARDED_BY(trace_observer_lock_) = false;
  95. base::Lock lock_; // Protects subsequent members.
  96. scoped_refptr<base::SequencedTaskRunner> task_runner_ GUARDED_BY(lock_);
  97. std::map<PowerModeVoter*, TracedPowerMode> votes_ GUARDED_BY(lock_);
  98. std::map<PowerModeVoter*, base::TimeTicks /*effective_time*/> pending_resets_
  99. GUARDED_BY(lock_);
  100. base::TimeTicks next_pending_vote_update_time_ GUARDED_BY(lock_);
  101. TracedPowerMode active_mode_ GUARDED_BY(lock_);
  102. base::TimeTicks active_mode_changed_timestamp_ GUARDED_BY(lock_);
  103. int update_task_sequence_number_ GUARDED_BY(lock_) = 0;
  104. scoped_refptr<base::ObserverListThreadSafe<Observer>> observers_
  105. GUARDED_BY(lock_);
  106. bool has_observers_ GUARDED_BY(lock_) = false;
  107. bool charging_mode_enabled_ = true;
  108. // Owned by the arbiter but otherwise behaves like a regular voter.
  109. std::unique_ptr<ChargingPowerModeVoter> charging_voter_;
  110. };
  111. } // namespace power_scheduler
  112. #endif // COMPONENTS_POWER_SCHEDULER_POWER_MODE_ARBITER_H_