| 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 // TODO(bashi): Renaming (throttled -> warning, suspended -> critical) is | |
| 151 // ongoing. Get variation parameters from both until server-side change | |
| 152 // is done. crbug.com/696844 | |
| 153 SetIntVariationParameter(params, "expected_renderer_size", | |
| 154 &expected_renderer_size_); | |
| 155 SetIntVariationParameter(params, "new_renderers_until_throttled", | |
| 156 &new_renderers_until_throttled_); | |
| 157 SetIntVariationParameter(params, "new_renderers_until_warning", | |
| 158 &new_renderers_until_throttled_); | |
| 159 SetIntVariationParameter(params, "new_renderers_until_suspended", | |
| 160 &new_renderers_until_suspended_); | |
| 161 SetIntVariationParameter(params, "new_renderers_until_critical", | |
| 162 &new_renderers_until_suspended_); | |
| 163 SetIntVariationParameter(params, "new_renderers_back_to_normal", | |
| 164 &new_renderers_back_to_normal_); | |
| 165 SetIntVariationParameter(params, "new_renderers_back_to_throttled", | |
| 166 &new_renderers_back_to_throttled_); | |
| 167 SetIntVariationParameter(params, "new_renderers_back_to_warning", | |
| 168 &new_renderers_back_to_throttled_); | |
| 169 SetSecondsVariationParameter(params, "minimum_transition_period", | |
| 170 &minimum_transition_period_); | |
| 171 SetSecondsVariationParameter(params, "monitoring_interval", | |
| 172 &monitoring_interval_); | |
| 173 } | |
| 174 | |
| 175 bool MemoryStateUpdater::ValidateParameters() { | |
| 176 return (new_renderers_until_throttled_ > new_renderers_until_suspended_) && | |
| 177 (new_renderers_back_to_normal_ > new_renderers_back_to_throttled_) && | |
| 178 (new_renderers_back_to_normal_ > new_renderers_until_throttled_) && | |
| 179 (new_renderers_back_to_throttled_ > new_renderers_until_suspended_); | |
| 180 } | |
| 181 | |
| 182 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2718963002:
Drop the global memory state from memory coordinator (Closed)
