Adding GpuMemoryManager to track GpuCommandBufferStub visibility and last_used_time and dictate mem…

content/common/gpu/gpu_memory_manager.cc

+// Copyright (c) 2012 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 "content/common/gpu/gpu_memory_manager.h"
+
+#if defined(ENABLE_GPU)
+
+#include <set>
+#include <algorithm>
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "content/common/gpu/gpu_command_buffer_stub.h"
+#include "content/common/gpu/gpu_memory_allocation.h"
+
+namespace {
+
+static const int kResourceSizeForegroundTab = 100 * 1024 * 1024;

[nduca, 2012/02/01 00:01:17]

you dont need static keywords inside a anon namespace.

[nduca, 2012/02/01 00:01:17]

Put a comment block explaining what these magic values mean.

+static const int kResourceSizeBackgroundTab = 50 * 1024 * 1024;
+static const int kResourceSizeHibernatedTab = 0;
+static const size_t kDefaultMaxSurfacesWithFrontbufferSoftLimit = 8;

[nduca, 2012/02/01 00:01:17]

It seem so to me we should set kResourceSizeNonHibernated and not have a fore vs
back since we're not statically allocating. Moreover, we should set it to 1. 1
byte. E.g. nonzero. And clearly explain its intent is to just be nonzero and
that in the future they will go away entirely.

+
+// Set up three allocation values for the three possible stub states
+static const GpuMemoryAllocation all_buffers_allocation(
+    kResourceSizeForegroundTab, true, true);
+static const GpuMemoryAllocation front_buffers_allocation(
+    kResourceSizeBackgroundTab, true, false);
+static const GpuMemoryAllocation no_buffers_allocation(
+    kResourceSizeHibernatedTab, false, false);
+
+}
+
+GpuMemoryManager::GpuMemoryManager(GpuMemoryManagerClient* client)
+    : client_(client),
+      manage_scheduled_(false),
+      max_surfaces_with_frontbuffer_soft_limit_(
+          kDefaultMaxSurfacesWithFrontbufferSoftLimit),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+GpuMemoryManager::~GpuMemoryManager() {
+}
+
+bool GpuMemoryManager::StubWithSurfaceComparator::operator()(
+    GpuCommandBufferStubBase* lhs,
+    GpuCommandBufferStubBase* rhs) {
+  GpuCommandBufferStubBase::SurfaceState* lhs_ss = lhs->surface_state();
+  GpuCommandBufferStubBase::SurfaceState* rhs_ss = rhs->surface_state();
+  DCHECK(lhs_ss && rhs_ss);
+  if (lhs_ss->visible)
+    return !rhs_ss->visible ||
+        (lhs_ss->last_used_time > rhs_ss->last_used_time);
+  else
+    return !rhs_ss->visible &&
+        (lhs_ss->last_used_time > rhs_ss->last_used_time);
+};
+
+void GpuMemoryManager::ScheduleManage() {
+  if (manage_scheduled_)
+    return;
+  MessageLoop::current()->PostTask(
+    FROM_HERE,
+    base::Bind(&GpuMemoryManager::Manage, weak_factory_.GetWeakPtr()));
+  manage_scheduled_ = true;
+}
+
+// The current Manage algorithm simply classifies contexts (stubs) into
+// "foreground", "background", or "hibernated" categories.
+// For each of these three categories, there are predefined memory allocation
+// limits and front/backbuffer states.
+//
+// Stubs may or may not have a surfaces, and the rules are different for each.
+//
+// The rules for categorizing contexts with a surface are:
+//  1. Foreground: All visible surfaces.
+//                 * Must have both front and back buffer.
+//
+//  2. Background: Non visible surfaces, which have not surpassed the
+//                 max_surfaces_with_frontbuffer_soft_limit_ limit.
+//                 * Will have only a frontbuffer.
+//
+//  3. Hibernated: Non visible surfaces, which have surpassed the
+//                 max_surfaces_with_frontbuffer_soft_limit_ limit.
+//                 * Will not have either buffer.
+//
+// The rule for categorizing contexts without a surface is:
+//  * Stubs without a surface instead have an affected_surface_ids list.
+//    Its state must be the same as the most visible surface it affects.
+void GpuMemoryManager::Manage() {
+  manage_scheduled_ = false;
+
+  // Create stub lists by separating out the two types received from client
+  std::vector<GpuCommandBufferStubBase*> stubs_with_surface;
+  std::vector<GpuCommandBufferStubBase*> stubs_without_surface;
+  {
+    std::vector<GpuCommandBufferStubBase*> stubs;
+    client_->AppendAllCommandBufferStubs(stubs);
+
+    for (std::vector<GpuCommandBufferStubBase*>::iterator it = stubs.begin();
+        it != stubs.end(); ++it) {
+      GpuCommandBufferStubBase* stub = *it;
+      if (stub->surface_state())
+        stubs_with_surface.push_back(stub);
+      else
+        stubs_without_surface.push_back(stub);
+    }
+  }
+
+  // Sort stubs with surface into {visibility,last_used_time} order using
+  // custom comparator
+  std::sort(stubs_with_surface.begin(), stubs_with_surface.end(),
+      StubWithSurfaceComparator());
+
+  // Separate stubs with surfaces into three sets and send memory allocation
+  std::set<int32> all_buffers, front_buffers, no_buffers;
+
+  for (size_t i = 0; i < stubs_with_surface.size(); ++i) {
+    GpuCommandBufferStubBase* stub = stubs_with_surface[i];
+    if (stub->surface_state()->visible) {
+      all_buffers.insert(stub->surface_state()->surface_id);
+      stub->SendMemoryAllocationToProxy(all_buffers_allocation);
+    } else if (i < max_surfaces_with_frontbuffer_soft_limit_) {
+      front_buffers.insert(stub->surface_state()->surface_id);
+      stub->SendMemoryAllocationToProxy(front_buffers_allocation);
+    } else {
+      no_buffers.insert(stub->surface_state()->surface_id);
+      stub->SendMemoryAllocationToProxy(no_buffers_allocation);
+    }
+  }
+
+  // Now, go through the stubs without surfaces and send memory allocations
+  // based on buckets we just divided.  Because there may be multiple affected
+  // surfaces, use the state of the most "important" affected surface.
+  for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
+      stubs_without_surface.begin(); it != stubs_without_surface.end(); ++it) {
+    GpuCommandBufferStubBase* stub = *it;
+    if (stub->affected_surface_ids().empty())
+      continue;
+    if (std::find_first_of(all_buffers.begin(),
+                           all_buffers.end(),
+                           stub->affected_surface_ids().begin(),
+                           stub->affected_surface_ids().end()) !=
+                               all_buffers.end()) {
+      stub->SendMemoryAllocationToProxy(all_buffers_allocation);
+    } else if (std::find_first_of(front_buffers.begin(),
+                                  front_buffers.end(),
+                                  stub->affected_surface_ids().begin(),
+                                  stub->affected_surface_ids().end()) !=
+                                      front_buffers.end()) {
+      stub->SendMemoryAllocationToProxy(front_buffers_allocation);
+    } else if (std::find_first_of(no_buffers.begin(),
+                                  no_buffers.end(),
+                                  stub->affected_surface_ids().begin(),
+                                  stub->affected_surface_ids().end()) !=
+                                      no_buffers.end()) {
+      stub->SendMemoryAllocationToProxy(no_buffers_allocation);
+    } else {
+      DLOG(ERROR) << "GpuCommandBufferStub::affected_surface_ids are not "
+                     "valid.";
+    }
+  }
+}
+
+void GpuMemoryManager::SetMaxSurfacesWithFrontbufferSoftLimit(size_t limit) {
+  max_surfaces_with_frontbuffer_soft_limit_ = limit;
+}
+
+#endif