OLD | NEW |
(Empty) | |
| 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 |
| 5 #include "content/browser/memory/memory_state_updater.h" |
| 6 |
| 7 #include "base/metrics/histogram_macros.h" |
| 8 #include "base/strings/string_number_conversions.h" |
| 9 #include "components/variations/variations_associated_data.h" |
| 10 #include "content/browser/memory/memory_monitor.h" |
| 11 |
| 12 namespace content { |
| 13 |
| 14 namespace { |
| 15 |
| 16 // A expected renderer size. These values come from the median of appropriate |
| 17 // UMA stats. |
| 18 #if defined(OS_ANDROID) || defined(OS_IOS) |
| 19 const int kDefaultExpectedRendererSizeMB = 40; |
| 20 #elif defined(OS_WIN) |
| 21 const int kDefaultExpectedRendererSizeMB = 70; |
| 22 #else // Mac, Linux, and ChromeOS |
| 23 const int kDefaultExpectedRendererSizeMB = 120; |
| 24 #endif |
| 25 |
| 26 // Default values for parameters to determine the global state. |
| 27 const int kDefaultNewRenderersUntilThrottled = 4; |
| 28 const int kDefaultNewRenderersUntilSuspended = 2; |
| 29 const int kDefaultNewRenderersBackToNormal = 5; |
| 30 const int kDefaultNewRenderersBackToThrottled = 3; |
| 31 const int kDefaultMinimumTransitionPeriodSeconds = 30; |
| 32 const int kDefaultMonitoringIntervalSeconds = 5; |
| 33 |
| 34 void SetIntVariationParameter(const std::map<std::string, std::string> params, |
| 35 const char* name, |
| 36 int* target) { |
| 37 const auto& iter = params.find(name); |
| 38 if (iter == params.end()) |
| 39 return; |
| 40 int value; |
| 41 if (!iter->second.empty() && base::StringToInt(iter->second, &value)) { |
| 42 DCHECK(value > 0); |
| 43 *target = value; |
| 44 } |
| 45 } |
| 46 |
| 47 void SetSecondsVariationParameter( |
| 48 const std::map<std::string, std::string> params, |
| 49 const char* name, |
| 50 base::TimeDelta* target) { |
| 51 const auto& iter = params.find(name); |
| 52 if (iter == params.end()) |
| 53 return; |
| 54 int value; |
| 55 if (!iter->second.empty() && base::StringToInt(iter->second, &value)) { |
| 56 DCHECK(value > 0); |
| 57 *target = base::TimeDelta::FromSeconds(value); |
| 58 } |
| 59 } |
| 60 |
| 61 } // namespace |
| 62 |
| 63 MemoryStateUpdater::MemoryStateUpdater( |
| 64 MemoryCoordinatorImpl* coordinator, |
| 65 scoped_refptr<base::SingleThreadTaskRunner> task_runner) |
| 66 : coordinator_(coordinator), task_runner_(task_runner) { |
| 67 DCHECK(coordinator_); |
| 68 InitializeParameters(); |
| 69 DCHECK(ValidateParameters()); |
| 70 } |
| 71 |
| 72 MemoryStateUpdater::~MemoryStateUpdater() {} |
| 73 |
| 74 base::MemoryState MemoryStateUpdater::CalculateNextState() { |
| 75 using MemoryState = base::MemoryState; |
| 76 |
| 77 int available = |
| 78 coordinator_->memory_monitor()->GetFreeMemoryUntilCriticalMB(); |
| 79 |
| 80 // TODO(chrisha): Move this histogram recording to a better place when |
| 81 // https://codereview.chromium.org/2479673002/ is landed. |
| 82 UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Coordinator.FreeMemoryUntilCritical", |
| 83 available); |
| 84 |
| 85 if (available <= 0) |
| 86 return MemoryState::SUSPENDED; |
| 87 |
| 88 auto current_state = coordinator_->GetGlobalMemoryState(); |
| 89 int expected_renderer_count = available / expected_renderer_size_; |
| 90 |
| 91 switch (current_state) { |
| 92 case MemoryState::NORMAL: |
| 93 if (expected_renderer_count <= new_renderers_until_suspended_) |
| 94 return MemoryState::SUSPENDED; |
| 95 if (expected_renderer_count <= new_renderers_until_throttled_) |
| 96 return MemoryState::THROTTLED; |
| 97 return MemoryState::NORMAL; |
| 98 case MemoryState::THROTTLED: |
| 99 if (expected_renderer_count <= new_renderers_until_suspended_) |
| 100 return MemoryState::SUSPENDED; |
| 101 if (expected_renderer_count >= new_renderers_back_to_normal_) |
| 102 return MemoryState::NORMAL; |
| 103 return MemoryState::THROTTLED; |
| 104 case MemoryState::SUSPENDED: |
| 105 if (expected_renderer_count >= new_renderers_back_to_normal_) |
| 106 return MemoryState::NORMAL; |
| 107 if (expected_renderer_count >= new_renderers_back_to_throttled_) |
| 108 return MemoryState::THROTTLED; |
| 109 return MemoryState::SUSPENDED; |
| 110 case MemoryState::UNKNOWN: |
| 111 // Fall through |
| 112 default: |
| 113 NOTREACHED(); |
| 114 return MemoryState::UNKNOWN; |
| 115 } |
| 116 } |
| 117 |
| 118 void MemoryStateUpdater::UpdateState() { |
| 119 auto current_state = coordinator_->GetGlobalMemoryState(); |
| 120 auto next_state = CalculateNextState(); |
| 121 if (coordinator_->ChangeStateIfNeeded(current_state, next_state)) { |
| 122 ScheduleUpdateState(minimum_transition_period_); |
| 123 } else { |
| 124 ScheduleUpdateState(monitoring_interval_); |
| 125 } |
| 126 } |
| 127 |
| 128 void MemoryStateUpdater::ScheduleUpdateState(base::TimeDelta delta) { |
| 129 update_state_closure_.Reset(base::Bind(&MemoryStateUpdater::UpdateState, |
| 130 base::Unretained(this))); |
| 131 task_runner_->PostDelayedTask(FROM_HERE, update_state_closure_.callback(), |
| 132 delta); |
| 133 } |
| 134 |
| 135 void MemoryStateUpdater::InitializeParameters() { |
| 136 expected_renderer_size_ = kDefaultExpectedRendererSizeMB; |
| 137 new_renderers_until_throttled_ = kDefaultNewRenderersUntilThrottled; |
| 138 new_renderers_until_suspended_ = kDefaultNewRenderersUntilSuspended; |
| 139 new_renderers_back_to_normal_ = kDefaultNewRenderersBackToNormal; |
| 140 new_renderers_back_to_throttled_ = kDefaultNewRenderersBackToThrottled; |
| 141 minimum_transition_period_ = |
| 142 base::TimeDelta::FromSeconds(kDefaultMinimumTransitionPeriodSeconds); |
| 143 monitoring_interval_ = |
| 144 base::TimeDelta::FromSeconds(kDefaultMonitoringIntervalSeconds); |
| 145 |
| 146 // Override default parameters with variations. |
| 147 static constexpr char kMemoryCoordinatorV0Trial[] = "MemoryCoordinatorV0"; |
| 148 std::map<std::string, std::string> params; |
| 149 variations::GetVariationParams(kMemoryCoordinatorV0Trial, ¶ms); |
| 150 SetIntVariationParameter(params, "expected_renderer_size", |
| 151 &expected_renderer_size_); |
| 152 SetIntVariationParameter(params, "new_renderers_until_throttled", |
| 153 &new_renderers_until_throttled_); |
| 154 SetIntVariationParameter(params, "new_renderers_until_suspended", |
| 155 &new_renderers_until_suspended_); |
| 156 SetIntVariationParameter(params, "new_renderers_back_to_normal", |
| 157 &new_renderers_back_to_normal_); |
| 158 SetIntVariationParameter(params, "new_renderers_back_to_throttled", |
| 159 &new_renderers_back_to_throttled_); |
| 160 SetSecondsVariationParameter(params, "minimum_transition_period", |
| 161 &minimum_transition_period_); |
| 162 SetSecondsVariationParameter(params, "monitoring_interval", |
| 163 &monitoring_interval_); |
| 164 } |
| 165 |
| 166 bool MemoryStateUpdater::ValidateParameters() { |
| 167 return (new_renderers_until_throttled_ > new_renderers_until_suspended_) && |
| 168 (new_renderers_back_to_normal_ > new_renderers_back_to_throttled_) && |
| 169 (new_renderers_back_to_normal_ > new_renderers_until_throttled_) && |
| 170 (new_renderers_back_to_throttled_ > new_renderers_until_suspended_); |
| 171 } |
| 172 |
| 173 } // namespace content |
OLD | NEW |