Global GPU memory manager for android webview

android_webview/browser/hardware_renderer.cc

 // Copyright 2014 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.
 
 #include "android_webview/browser/hardware_renderer.h"
 
 #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"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #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;
 
 }  // namespace
 
 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());
   }
 
   ScopedAppGLStateRestore state_restore(
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
   internal::ScopedAllowGL allow_gl;
 
   gl_surface_ = new AwGLSurface;
   bool success =
       shared_renderer_state_->GetCompositor()->
           InitializeHwDraw(gl_surface_);
   DCHECK(success);
 }
 
 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);
   internal::ScopedAllowGL allow_gl;
 
   shared_renderer_state_->GetCompositor()->ReleaseHwDraw();
   gl_surface_ = NULL;
 }
 
 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
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   if (!current_context) {
     DLOG(ERROR) << "DrawGL called without EGLContext";
     return false;
   }
 
   // TODO(boliu): Handle context loss.
   if (last_egl_context_ != current_context)
     DLOG(WARNING) << "EGLContextChanged";
 
   ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW);
   internal::ScopedAllowGL allow_gl;
 
   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(
       state_restore.framebuffer_binding_ext());
 
   gfx::Transform transform;
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(input.scroll_offset.x(), input.scroll_offset.y());
   gfx::Rect clip_rect(draw_info->clip_left,
                       draw_info->clip_top,
@@ skipping 44 matching lines @@
 
   if (!eglGetCurrentContext()) {
     NOTREACHED();
     return false;
   }
 
   DCHECK_EQ(last_egl_context_, eglGetCurrentContext());
 
   // 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");
   ScopedAppGLStateRestore state_restore(
       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
 void HardwareRenderer::CalculateTileMemoryPolicy() {
   CommandLine* cl = CommandLine::ForCurrentProcess();
 
   const char kDefaultTileSize[] = "384";
   if (!cl->HasSwitch(switches::kDefaultTileWidth))
     cl->AppendSwitchASCII(switches::kDefaultTileWidth, kDefaultTileSize);
 
@@ skipping 92 matching lines @@
   base::RefCountedThreadSafe<DeferredGpuCommandService>::AddRef();
 }
 
 void DeferredGpuCommandService::Release() const {
   base::RefCountedThreadSafe<DeferredGpuCommandService>::Release();
 }
 
 }  // namespace internal
 
 }  // namespace android_webview