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