Global GPU memory manager for android webview

android_webview/browser/hardware_renderer.cc

Index: android_webview/browser/hardware_renderer.cc
diff --git a/android_webview/browser/hardware_renderer.cc b/android_webview/browser/hardware_renderer.cc
index a45da7ff724231c5775bfc66b33474068a95fe18..1481529d9b611fcf10d1f9128a2ebe221c33b87a 100644
--- a/android_webview/browser/hardware_renderer.cc
+++ b/android_webview/browser/hardware_renderer.cc
@@ -6,7 +6,6 @@
 
 #include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/browser_view_renderer_client.h"
-#include "android_webview/browser/gl_view_renderer_manager.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/command_line.h"
@@ -19,18 +18,10 @@
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 
-using content::BrowserThread;
-
 namespace android_webview {
 
 namespace {
 
-// Used to calculate memory and resource allocation. Determined experimentally.
-const size_t g_memory_multiplier = 10;
-const size_t g_num_gralloc_limit = 150;
-const size_t kBytesPerPixel = 4;
-const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
-
 base::LazyInstance<scoped_refptr<internal::DeferredGpuCommandService> >
     g_service = LAZY_INSTANCE_INITIALIZER;
 
@@ -39,9 +30,10 @@ base::LazyInstance<scoped_refptr<internal::DeferredGpuCommandService> >
 HardwareRenderer::HardwareRenderer(SharedRendererState* state)
     : shared_renderer_state_(state),
       last_egl_context_(eglGetCurrentContext()),
-      manager_key_(GLViewRendererManager::GetInstance()->PushBack(
+      renderer_manager_key_(GLViewRendererManager::GetInstance()->PushBack(
           shared_renderer_state_)) {
   DCHECK(last_egl_context_);
+

[boliu, 2014/04/28 22:22:15]

spurious new line

[hush (inactive), 2014/04/30 20:50:17]

Done.

   if (!g_service.Get()) {
     g_service.Get() = new internal::DeferredGpuCommandService;
     content::SynchronousCompositor::SetGpuService(g_service.Get());
@@ -59,8 +51,8 @@ HardwareRenderer::HardwareRenderer(SharedRendererState* state)
 }
 
 HardwareRenderer::~HardwareRenderer() {
-  GLViewRendererManager* mru = GLViewRendererManager::GetInstance();
-  mru->Remove(manager_key_);
+  GLViewRendererManager* render_manager = GLViewRendererManager::GetInstance();
+  render_manager->Remove(renderer_manager_key_);
 
   ScopedAppGLStateRestore state_restore(
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
@@ -72,7 +64,7 @@ HardwareRenderer::~HardwareRenderer() {
 
 bool HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info, DrawGLResult* result) {
   TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
-  GLViewRendererManager::GetInstance()->DidDrawGL(manager_key_);
+  GLViewRendererManager::GetInstance()->DidDrawGL(renderer_manager_key_);
   const DrawGLInput input = shared_renderer_state_->GetDrawGLInput();
 
   // We need to watch if the current Android context has changed and enforce
@@ -93,16 +85,10 @@ bool HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info, DrawGLResult* result) {
   if (draw_info->mode == AwDrawGLInfo::kModeProcess)
     return false;
 
-  // Update memory budget. This will no-op in compositor if the policy has not
-  // changed since last draw.
-  content::SynchronousCompositorMemoryPolicy policy;
-  policy.bytes_limit = g_memory_multiplier * kBytesPerPixel *
-                       input.global_visible_rect.width() *
-                       input.global_visible_rect.height();
-  // Round up to a multiple of kMemoryAllocationStep.
-  policy.bytes_limit =
-      (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
-  policy.num_resources_limit = g_num_gralloc_limit;
+  // Memory policy is set by BrowserViewRenderer on UI thread.
+  content::SynchronousCompositorMemoryPolicy policy =
+      shared_renderer_state_->GetMemoryPolicy();
+
   SetMemoryPolicy(policy);
 
   gl_surface_->SetBackingFrameBufferObject(
@@ -167,10 +153,8 @@ bool HardwareRenderer::TrimMemory(int level, bool visible) {
 
   // Just set the memory limit to 0 and drop all tiles. This will be reset to
   // normal levels in the next DrawGL call.
-  content::SynchronousCompositorMemoryPolicy policy;
-  policy.bytes_limit = 0;
-  policy.num_resources_limit = 0;
-  if (memory_policy_ == policy)
+  content::SynchronousCompositorMemoryPolicy zero_policy;
+  if (shared_renderer_state_->GetMemoryPolicy() == zero_policy)
     return false;
 
   TRACE_EVENT0("android_webview", "HardwareRenderer::TrimMemory");
@@ -178,18 +162,13 @@ bool HardwareRenderer::TrimMemory(int level, bool visible) {
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
   internal::ScopedAllowGL allow_gl;
 
-  SetMemoryPolicy(policy);
+  SetMemoryPolicy(zero_policy);
   return true;
 }
 
 void HardwareRenderer::SetMemoryPolicy(
-    content::SynchronousCompositorMemoryPolicy& new_policy) {
-  if (memory_policy_ == new_policy)

[boliu, 2014/04/28 22:22:15]

This check is still important, but I understand the source of truth has moved
and modified somewhere else. How about add a "bool memory_policy_dirty" to
shared state, BVR can set it in OnDraw if things changed, and HR only updates
policy if it's true.

It could also make TrimMemory work entirely within BVR.

[hush (inactive), 2014/04/30 20:50:17]

I add the boolean in shared renderer state and hardware renderer will check if
the policy is dirty before setting the policy to compositor. And after that, the
dirty boolean will false.

On 2014/04/28 22:22:15, boliu wrote:

-    return;
-
-  memory_policy_ = new_policy;
-  shared_renderer_state_->GetCompositor()->
-      SetMemoryPolicy(memory_policy_);
+    content::SynchronousCompositorMemoryPolicy& policy) {
+  shared_renderer_state_->GetCompositor()->SetMemoryPolicy(policy);
 }
 
 // static