cast_system_memory_pressure_evaluator.cc 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
  1. // Copyright 2016 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. #include "chromecast/browser/cast_system_memory_pressure_evaluator.h"
  5. #include <algorithm>
  6. #include "base/bind.h"
  7. #include "base/command_line.h"
  8. #include "base/location.h"
  9. #include "base/logging.h"
  10. #include "base/process/process_metrics.h"
  11. #include "base/strings/string_number_conversions.h"
  12. #include "base/task/single_thread_task_runner.h"
  13. #include "base/threading/thread_task_runner_handle.h"
  14. #include "chromecast/base/chromecast_switches.h"
  15. #include "chromecast/base/metrics/cast_metrics_helper.h"
  16. #define MAKE_SURE_THREAD(callback, ...) \
  17. if (!task_runner_->BelongsToCurrentThread()) { \
  18. task_runner_->PostTask( \
  19. FROM_HERE, \
  20. base::BindOnce(&CastSystemMemoryPressureEvaluator::callback, \
  21. weak_ptr_factory_.GetWeakPtr(), ##__VA_ARGS__)); \
  22. return; \
  23. }
  24. namespace chromecast {
  25. namespace {
  26. // Memory thresholds (as fraction of total memory) for memory pressure levels.
  27. // See more detailed description of pressure heuristic in PollPressureLevel.
  28. // TODO(halliwell): tune thresholds based on data.
  29. constexpr float kCriticalMemoryFraction = 0.25f;
  30. constexpr float kModerateMemoryFraction = 0.4f;
  31. // Default Relaxed memory thresholds selectively applied to a few apps.
  32. constexpr float kRelaxedCriticalMemoryFraction = 0.1f;
  33. constexpr float kRelaxedModerateMemoryFraction = 0.2f;
  34. // Memory thresholds in MB for the simple heuristic based on 'free' memory.
  35. constexpr int kCriticalFreeMemoryKB = 20 * 1024;
  36. constexpr int kModerateFreeMemoryKB = 30 * 1024;
  37. constexpr int kPollingIntervalMS = 5000;
  38. int GetSystemReservedKb() {
  39. int rtn_kb_ = 0;
  40. const base::CommandLine* command_line(base::CommandLine::ForCurrentProcess());
  41. base::StringToInt(
  42. command_line->GetSwitchValueASCII(switches::kMemPressureSystemReservedKb),
  43. &rtn_kb_);
  44. DCHECK(rtn_kb_ >= 0);
  45. return std::max(rtn_kb_, 0);
  46. }
  47. } // namespace
  48. CastSystemMemoryPressureEvaluator::CastSystemMemoryPressureEvaluator(
  49. std::unique_ptr<memory_pressure::MemoryPressureVoter> voter)
  50. : memory_pressure::SystemMemoryPressureEvaluator(std::move(voter)),
  51. critical_memory_fraction_command_line_(
  52. GetSwitchValueDouble(switches::kCastMemoryPressureCriticalFraction,
  53. -1.0f)),
  54. moderate_memory_fraction_command_line_(
  55. GetSwitchValueDouble(switches::kCastMemoryPressureModerateFraction,
  56. -1.0f)),
  57. system_reserved_kb_(GetSystemReservedKb()),
  58. task_runner_(base::ThreadTaskRunnerHandle::Get()),
  59. weak_ptr_factory_(this) {
  60. relaxed_critical_memory_fraction_ = kRelaxedCriticalMemoryFraction;
  61. relaxed_moderate_memory_fraction_ = kRelaxedModerateMemoryFraction;
  62. critical_memory_fraction_ = critical_memory_fraction_command_line_;
  63. moderate_memory_fraction_ = moderate_memory_fraction_command_line_;
  64. // If the fractions from command line parameters are invalid they are subject
  65. // to adjustment.
  66. AdjustMemoryFractions(false);
  67. PollPressureLevel();
  68. }
  69. CastSystemMemoryPressureEvaluator::~CastSystemMemoryPressureEvaluator() =
  70. default;
  71. void CastSystemMemoryPressureEvaluator::PollPressureLevel() {
  72. DCHECK(task_runner_->BelongsToCurrentThread());
  73. base::MemoryPressureListener::MemoryPressureLevel level =
  74. base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
  75. base::SystemMemoryInfoKB info;
  76. if (!base::GetSystemMemoryInfo(&info)) {
  77. LOG(ERROR) << "GetSystemMemoryInfo failed";
  78. } else if (system_reserved_kb_ != 0 || info.available != 0) {
  79. // Preferred memory pressure heuristic:
  80. // 1. Use /proc/meminfo's MemAvailable if possible, fall back to estimate
  81. // of free + buffers + cached otherwise.
  82. const int total_available = (info.available != 0)
  83. ? info.available
  84. : (info.free + info.buffers + info.cached);
  85. // 2. Allow some memory to be 'reserved' on command line.
  86. const int available = total_available - system_reserved_kb_;
  87. const int total = info.total - system_reserved_kb_;
  88. DCHECK_GT(total, 0);
  89. const float ratio = available / static_cast<float>(total);
  90. if (ratio < critical_memory_fraction_)
  91. level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
  92. else if (ratio < moderate_memory_fraction_)
  93. level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
  94. } else {
  95. // Backup method purely using 'free' memory. It may generate more
  96. // pressure events than necessary, since more memory may actually be free.
  97. if (info.free < kCriticalFreeMemoryKB)
  98. level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
  99. else if (info.free < kModerateFreeMemoryKB)
  100. level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
  101. }
  102. UpdateMemoryPressureLevel(level);
  103. task_runner_->PostDelayedTask(
  104. FROM_HERE,
  105. base::BindOnce(&CastSystemMemoryPressureEvaluator::PollPressureLevel,
  106. weak_ptr_factory_.GetWeakPtr()),
  107. base::Milliseconds(kPollingIntervalMS));
  108. }
  109. void CastSystemMemoryPressureEvaluator::UpdateMemoryPressureLevel(
  110. base::MemoryPressureListener::MemoryPressureLevel new_level) {
  111. DCHECK(task_runner_->BelongsToCurrentThread());
  112. auto old_vote = current_vote();
  113. SetCurrentVote(new_level);
  114. SendCurrentVote(/* notify = */ current_vote() !=
  115. base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
  116. if (old_vote == current_vote())
  117. return;
  118. metrics::CastMetricsHelper::GetInstance()->RecordApplicationEventWithValue(
  119. "Memory.Pressure.LevelChange", new_level);
  120. }
  121. void CastSystemMemoryPressureEvaluator::AdjustMemoryFractions(bool relax) {
  122. DCHECK(task_runner_->BelongsToCurrentThread());
  123. if (critical_memory_fraction_command_line_ < 0) {
  124. critical_memory_fraction_ =
  125. relax ? relaxed_critical_memory_fraction_ : kCriticalMemoryFraction;
  126. }
  127. if (moderate_memory_fraction_command_line_ < 0) {
  128. moderate_memory_fraction_ =
  129. relax ? relaxed_moderate_memory_fraction_ : kModerateMemoryFraction;
  130. }
  131. LOG(INFO) << __func__
  132. << ": critical_memory_fraction_=" << critical_memory_fraction_
  133. << ", moderate_memory_fraction_=" << moderate_memory_fraction_;
  134. }
  135. void CastSystemMemoryPressureEvaluator::ConfigRelaxMemoryPressureThresholds(
  136. float relaxed_critical_memory_fraction,
  137. float relaxed_moderate_memory_fraction) {
  138. MAKE_SURE_THREAD(ConfigRelaxMemoryPressureThresholds,
  139. relaxed_critical_memory_fraction,
  140. relaxed_moderate_memory_fraction);
  141. LOG(INFO) << __func__ << ", " << relaxed_critical_memory_fraction << ", "
  142. << relaxed_moderate_memory_fraction;
  143. if (relaxed_critical_memory_fraction > 0) {
  144. relaxed_critical_memory_fraction_ = relaxed_critical_memory_fraction;
  145. }
  146. if (relaxed_moderate_memory_fraction > 0) {
  147. relaxed_moderate_memory_fraction_ = relaxed_moderate_memory_fraction;
  148. }
  149. }
  150. void CastSystemMemoryPressureEvaluator::RelaxMemoryPressureThresholds(
  151. std::string requesting_app_session_id) {
  152. MAKE_SURE_THREAD(RelaxMemoryPressureThresholds,
  153. std::move(requesting_app_session_id));
  154. apps_needing_relaxed_memory_pressure_thresholds_.insert(
  155. std::move(requesting_app_session_id));
  156. AdjustMemoryFractions(true);
  157. }
  158. void CastSystemMemoryPressureEvaluator::RestoreMemoryPressureThresholds(
  159. const std::string& requesting_app_session_id) {
  160. MAKE_SURE_THREAD(RestoreMemoryPressureThresholds, requesting_app_session_id);
  161. apps_needing_relaxed_memory_pressure_thresholds_.erase(
  162. requesting_app_session_id);
  163. if (apps_needing_relaxed_memory_pressure_thresholds_.empty()) {
  164. AdjustMemoryFractions(false);
  165. }
  166. }
  167. } // namespace chromecast