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/gpu_memory_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/transform.h"
 
@@ skipping 13 matching lines @@
     g_service = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 HardwareRenderer::HardwareRenderer(SharedRendererState* state)
     : shared_renderer_state_(state),
       last_egl_context_(eglGetCurrentContext()),
       manager_key_(GLViewRendererManager::GetInstance()->PushBack(
           shared_renderer_state_)) {
   DCHECK(last_egl_context_);
+
   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_);
 
+  content::SynchronousCompositorMemoryPolicy zero_policy;
+  SetMemoryPolicy(zero_policy);
+
   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");
@@ skipping 78 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 current_policy, zero_policy;
+  current_policy = GetMemoryPolicy();
+  if (current_policy == 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)
+  content::SynchronousCompositorMemoryPolicy current_policy;
+  current_policy = GetMemoryPolicy();
+
+  if (current_policy == new_policy)
     return;
 
-  memory_policy_ = new_policy;
+  GpuMemoryManager::GetInstance()->UpdateResources(
+      current_policy, new_policy, manager_key_);

[boliu, 2014/04/08 03:06:45]

Too aggressive and not stable? And I think it doesn't actually work since you
don't force call ManageTiles.

Stability is probably the most important issue. If we solve that, the other two
shouldn't be problems anymore...

What if we do something like this:
First webview, use half of available
Next one comes, use quarter
etc...

If first one ever draws again, it can adjust itself.
If first one never draws again, then at some point, we start dropping its tiles.

That's just my first idea that came to mind.

+
   shared_renderer_state_->GetCompositor()->
-      SetMemoryPolicy(memory_policy_);
+      SetMemoryPolicy(new_policy);
+}
+
+const content::SynchronousCompositorMemoryPolicy&
+    HardwareRenderer::GetMemoryPolicy() const {
+  return shared_renderer_state_->GetCompositor()->GetMemoryPolicy();
 }
 
 // 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