1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_MEMORY_PRESSURE_DIRECT_MEMORY_PRESSURE_CALCULATOR_LINUX_H_
#define COMPONENTS_MEMORY_PRESSURE_DIRECT_MEMORY_PRESSURE_CALCULATOR_LINUX_H_
#include "base/macros.h"
#include "base/process/process_metrics.h"
#include "components/memory_pressure/memory_pressure_calculator.h"
namespace base {
class TimeDelta;
}
namespace memory_pressure {
// OS-specific implementation of MemoryPressureCalculator. This is only defined
// and used on platforms that do not have native memory pressure signals
// (ChromeOS, Linux, Windows). OSes that do have native signals simply hook into
// the appropriate subsystem (Android, Mac OS X).
class DirectMemoryPressureCalculator : public MemoryPressureCalculator {
public:
// Exposed for unittesting. See .cc file for detailed discussion of these
// constants.
static const int kDefaultModerateThresholdPc;
static const int kDefaultCriticalThresholdPc;
// Default constructor. Will choose thresholds automatically based on the
// actual amount of system memory installed.
DirectMemoryPressureCalculator();
// Constructor with explicit memory thresholds. These represent the amount of
// free memory below which the applicable memory pressure state applies.
DirectMemoryPressureCalculator(int moderate_threshold_mb,
int critical_threshold_mb);
~DirectMemoryPressureCalculator() override {}
// Calculates the current pressure level.
MemoryPressureLevel CalculateCurrentPressureLevel() override;
int moderate_threshold_mb() const { return moderate_threshold_mb_; }
int critical_threshold_mb() const { return critical_threshold_mb_; }
private:
friend class TestDirectMemoryPressureCalculator;
MemoryPressureLevel PressureCausedByThrashing(
const base::SystemMemoryInfoKB& mem_info);
MemoryPressureLevel PressureCausedByOOM(
const base::SystemMemoryInfoKB& mem_info);
// Gets system memory status. This is virtual as a unittesting hook and by
// default this invokes base::GetSystemMemoryInfo.
virtual bool GetSystemMemoryInfo(base::SystemMemoryInfoKB* mem_info) const;
// We use CPU time instead of real time because this eliminates the variable
// of average system load. Consumer machines are idle most of the time, so if
// we used real time, the average faults/sec would be very low. As soon as
// the user loads anything, the instantaneous faults/sec would increase, and
// we would overreport the memory pressure.
//
// We also ignore system time because we don't want to include the time the OS
// takes to swap pages in/out on behalf of processes.
//
// Virtual as a unittesting hook.
virtual base::TimeDelta GetUserCpuTimeSinceBoot() const;
// Uses GetSystemMemoryInfo to automatically infer appropriate values for
// moderate_threshold_mb_ and critical_threshold_mb_.
void InferThresholds();
// Initialize the page fault monitor state so CalculateCurrentPressureLevel
// will have a delta to analyze.
virtual void InitPageFaultMonitor();
// Computes last_major_page_faults_/last_user_exec_time_ with some
// protection.
double AverageFaultsPerSecond() const;
// Threshold amounts of available memory that trigger pressure levels. See
// memory_pressure_monitor_win.cc for a discussion of reasonable values for
// these.
int moderate_threshold_mb_;
int critical_threshold_mb_;
// State needed by the hard page fault monitor. These values are assumed
// not to overflow.
base::TimeDelta last_user_exec_time_;
uint64_t last_major_page_faults_;
// An exponentially weighted moving average of the sampled faults/sec.
double current_faults_per_second_;
double low_pass_half_life_seconds_;
// |current_faults_per_second_| must be at least |kModerateMultiplier| *
// AverageFaultsPerSecond() to report moderate pressure, and similarly for
// critical pressure. Non-const members for unit testing.
//
// TODO(thomasanderson): Experimentally determine the correct value for these
// constants.
double moderate_multiplier_ = 5.0;
double critical_multiplier_ = 10.0;
DISALLOW_COPY_AND_ASSIGN(DirectMemoryPressureCalculator);
};
} // namespace memory_pressure
#endif // COMPONENTS_MEMORY_PRESSURE_DIRECT_MEMORY_PRESSURE_CALCULATOR_LINUX_H_
|
