| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/renderer_host/renderer_frame_manager.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/logging.h" | |
| 11 #include "base/memory/memory_coordinator_client_registry.h" | |
| 12 #include "base/memory/memory_coordinator_proxy.h" | |
| 13 #include "base/memory/memory_pressure_listener.h" | |
| 14 #include "base/memory/memory_pressure_monitor.h" | |
| 15 #include "base/memory/shared_memory.h" | |
| 16 #include "base/sys_info.h" | |
| 17 #include "build/build_config.h" | |
| 18 #include "components/display_compositor/host_shared_bitmap_manager.h" | |
| 19 #include "content/public/common/content_features.h" | |
| 20 | |
| 21 namespace content { | |
| 22 namespace { | |
| 23 | |
| 24 const int kModeratePressurePercentage = 50; | |
| 25 const int kCriticalPressurePercentage = 10; | |
| 26 | |
| 27 } // namespace | |
| 28 | |
| 29 RendererFrameManager* RendererFrameManager::GetInstance() { | |
| 30 return base::Singleton<RendererFrameManager>::get(); | |
| 31 } | |
| 32 | |
| 33 void RendererFrameManager::AddFrame(RendererFrameManagerClient* frame, | |
| 34 bool locked) { | |
| 35 RemoveFrame(frame); | |
| 36 if (locked) | |
| 37 locked_frames_[frame] = 1; | |
| 38 else | |
| 39 unlocked_frames_.push_front(frame); | |
| 40 CullUnlockedFrames(GetMaxNumberOfSavedFrames()); | |
| 41 } | |
| 42 | |
| 43 void RendererFrameManager::RemoveFrame(RendererFrameManagerClient* frame) { | |
| 44 std::map<RendererFrameManagerClient*, size_t>::iterator locked_iter = | |
| 45 locked_frames_.find(frame); | |
| 46 if (locked_iter != locked_frames_.end()) | |
| 47 locked_frames_.erase(locked_iter); | |
| 48 unlocked_frames_.remove(frame); | |
| 49 } | |
| 50 | |
| 51 void RendererFrameManager::LockFrame(RendererFrameManagerClient* frame) { | |
| 52 std::list<RendererFrameManagerClient*>::iterator unlocked_iter = | |
| 53 std::find(unlocked_frames_.begin(), unlocked_frames_.end(), frame); | |
| 54 if (unlocked_iter != unlocked_frames_.end()) { | |
| 55 DCHECK(locked_frames_.find(frame) == locked_frames_.end()); | |
| 56 unlocked_frames_.remove(frame); | |
| 57 locked_frames_[frame] = 1; | |
| 58 } else { | |
| 59 DCHECK(locked_frames_.find(frame) != locked_frames_.end()); | |
| 60 locked_frames_[frame]++; | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 void RendererFrameManager::UnlockFrame(RendererFrameManagerClient* frame) { | |
| 65 DCHECK(locked_frames_.find(frame) != locked_frames_.end()); | |
| 66 size_t locked_count = locked_frames_[frame]; | |
| 67 DCHECK(locked_count); | |
| 68 if (locked_count > 1) { | |
| 69 locked_frames_[frame]--; | |
| 70 } else { | |
| 71 RemoveFrame(frame); | |
| 72 unlocked_frames_.push_front(frame); | |
| 73 CullUnlockedFrames(GetMaxNumberOfSavedFrames()); | |
| 74 } | |
| 75 } | |
| 76 | |
| 77 size_t RendererFrameManager::GetMaxNumberOfSavedFrames() const { | |
| 78 int percentage = 100; | |
| 79 if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) { | |
| 80 switch (base::MemoryCoordinatorProxy::GetInstance()-> | |
| 81 GetCurrentMemoryState()) { | |
| 82 case base::MemoryState::NORMAL: | |
| 83 percentage = 100; | |
| 84 break; | |
| 85 case base::MemoryState::THROTTLED: | |
| 86 percentage = kCriticalPressurePercentage; | |
| 87 break; | |
| 88 case base::MemoryState::SUSPENDED: | |
| 89 case base::MemoryState::UNKNOWN: | |
| 90 NOTREACHED(); | |
| 91 break; | |
| 92 } | |
| 93 } else { | |
| 94 base::MemoryPressureMonitor* monitor = base::MemoryPressureMonitor::Get(); | |
| 95 | |
| 96 if (!monitor) | |
| 97 return max_number_of_saved_frames_; | |
| 98 | |
| 99 // Until we have a global OnMemoryPressureChanged event we need to query the | |
| 100 // value from our specific pressure monitor. | |
| 101 switch (monitor->GetCurrentPressureLevel()) { | |
| 102 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: | |
| 103 percentage = 100; | |
| 104 break; | |
| 105 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: | |
| 106 percentage = kModeratePressurePercentage; | |
| 107 break; | |
| 108 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: | |
| 109 percentage = kCriticalPressurePercentage; | |
| 110 break; | |
| 111 } | |
| 112 } | |
| 113 size_t frames = (max_number_of_saved_frames_ * percentage) / 100; | |
| 114 return std::max(static_cast<size_t>(1), frames); | |
| 115 } | |
| 116 | |
| 117 RendererFrameManager::RendererFrameManager() | |
| 118 : memory_pressure_listener_(new base::MemoryPressureListener( | |
| 119 base::Bind(&RendererFrameManager::OnMemoryPressure, | |
| 120 base::Unretained(this)))) { | |
| 121 base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this); | |
| 122 max_number_of_saved_frames_ = | |
| 123 #if defined(OS_ANDROID) | |
| 124 // If the amount of memory on the device is >= 3.5 GB, save up to 5 | |
| 125 // frames. | |
| 126 base::SysInfo::AmountOfPhysicalMemoryMB() < 1024 * 3.5f ? 1 : 5; | |
| 127 #else | |
| 128 std::min(5, 2 + (base::SysInfo::AmountOfPhysicalMemoryMB() / 256)); | |
| 129 #endif | |
| 130 max_handles_ = base::SharedMemory::GetHandleLimit() / 8.0f; | |
| 131 } | |
| 132 | |
| 133 RendererFrameManager::~RendererFrameManager() {} | |
| 134 | |
| 135 void RendererFrameManager::CullUnlockedFrames(size_t saved_frame_limit) { | |
| 136 if (unlocked_frames_.size() + locked_frames_.size() > 0) { | |
| 137 float handles_per_frame = | |
| 138 display_compositor::HostSharedBitmapManager::current() | |
| 139 ->AllocatedBitmapCount() * | |
| 140 1.0f / (unlocked_frames_.size() + locked_frames_.size()); | |
| 141 | |
| 142 saved_frame_limit = std::max( | |
| 143 1, | |
| 144 static_cast<int>(std::min(static_cast<float>(saved_frame_limit), | |
| 145 max_handles_ / handles_per_frame))); | |
| 146 } | |
| 147 while (!unlocked_frames_.empty() && | |
| 148 unlocked_frames_.size() + locked_frames_.size() > saved_frame_limit) { | |
| 149 size_t old_size = unlocked_frames_.size(); | |
| 150 // Should remove self from list. | |
| 151 unlocked_frames_.back()->EvictCurrentFrame(); | |
| 152 DCHECK_EQ(unlocked_frames_.size() + 1, old_size); | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 void RendererFrameManager::OnMemoryPressure( | |
| 157 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) { | |
| 158 switch (memory_pressure_level) { | |
| 159 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: | |
| 160 PurgeMemory(kModeratePressurePercentage); | |
| 161 break; | |
| 162 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: | |
| 163 PurgeMemory(kCriticalPressurePercentage); | |
| 164 break; | |
| 165 case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: | |
| 166 // No need to change anything when there is no pressure. | |
| 167 return; | |
| 168 } | |
| 169 } | |
| 170 | |
| 171 void RendererFrameManager::OnPurgeMemory() { | |
| 172 PurgeMemory(kCriticalPressurePercentage); | |
| 173 } | |
| 174 | |
| 175 void RendererFrameManager::PurgeMemory(int percentage) { | |
| 176 int saved_frame_limit = max_number_of_saved_frames_; | |
| 177 if (saved_frame_limit <= 1) | |
| 178 return; | |
| 179 CullUnlockedFrames(std::max(1, (saved_frame_limit * percentage) / 100)); | |
| 180 } | |
| 181 | |
| 182 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2811083002:
Move frame eviction into components (Closed)
