Shrink QueryTracker when freeing everything

Before this, FreeEverything wouldn't free the shm associated with the
QueryTracker, even when all queries have been deleted. shm being at a 2MB
granularity, it leaves at least 2MB of shm per page. This fixes it.

It removes the bucketing of QuerySyncs. The rationale is that the
MappedMemoryManager already does pooling in shm chunks, and one extra level of
pooling seems redundant.

BUG=None


Review URL: https://chromiumcodereview.appspot.com/12278025

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@183019 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 58 insertions, 12 deletions

diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index eb1dfcd..4a9fc0b 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -250,6 +250,7 @@ void GLES2Implementation::FreeUnusedSharedMemory() {
 
 void GLES2Implementation::FreeEverything() {
   Finish();
+  query_tracker_->Shrink();
   FreeUnusedSharedMemory();
   transfer_buffer_->Free();
   helper_->FreeRingBuffer();
diff --git a/gpu/command_buffer/client/query_tracker.cc b/gpu/command_buffer/client/query_tracker.cc
index ccb6962..5356ef5 100644
--- a/gpu/command_buffer/client/query_tracker.cc
+++ b/gpu/command_buffer/client/query_tracker.cc
@@ -24,8 +24,9 @@ QuerySyncManager::QuerySyncManager(MappedMemoryManager* manager)
 
 QuerySyncManager::~QuerySyncManager() {
   while (!buckets_.empty()) {
-    mapped_memory_->Free(buckets_.front());
-    buckets_.pop();
+    mapped_memory_->Free(buckets_.front()->syncs);
+    delete buckets_.front();
+    buckets_.pop_front();
   }
 }
 
@@ -40,21 +41,48 @@ bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) {
       return false;
     }
     QuerySync* syncs = static_cast<QuerySync*>(mem);
-    buckets_.push(syncs);
+    Bucket* bucket = new Bucket(syncs);
+    buckets_.push_back(bucket);
     for (size_t ii = 0; ii < kSyncsPerBucket; ++ii) {
-      free_queries_.push(QueryInfo(shm_id, shm_offset, syncs));
+      free_queries_.push_back(QueryInfo(bucket, shm_id, shm_offset, syncs));
       ++syncs;
       shm_offset += sizeof(*syncs);
     }
   }
   *info = free_queries_.front();
+  ++(info->bucket->used_query_count);
   info->sync->Reset();
-  free_queries_.pop();
+  free_queries_.pop_front();
   return true;
 }
 
 void QuerySyncManager::Free(const QuerySyncManager::QueryInfo& info) {
-  free_queries_.push(info);
+  DCHECK_GT(info.bucket->used_query_count, 0u);
+  --(info.bucket->used_query_count);
+  free_queries_.push_back(info);
+}
+
+void QuerySyncManager::Shrink() {
+  std::deque<QueryInfo> new_queue;
+  while (!free_queries_.empty()) {
+    if (free_queries_.front().bucket->used_query_count)
+      new_queue.push_back(free_queries_.front());
+    free_queries_.pop_front();
+  }
+  free_queries_.swap(new_queue);
+
+  std::deque<Bucket*> new_buckets;
+  while (!buckets_.empty()) {
+    Bucket* bucket = buckets_.front();
+    if (bucket->used_query_count) {
+      new_buckets.push_back(bucket);
+    } else {
+      mapped_memory_->Free(bucket->syncs);
+      delete bucket;
+    }
+    buckets_.pop_front();
+  }
+  buckets_.swap(new_buckets);
 }
 
 QueryTracker::Query::Query(GLuint id, GLenum target,
@@ -205,5 +233,9 @@ void QueryTracker::RemoveQuery(GLuint client_id, bool context_lost) {
   }
 }
 
+void QueryTracker::Shrink() {
+  query_sync_manager_.Shrink();
+}
+
 }  // namespace gles2
 }  // namespace gpu
diff --git a/gpu/command_buffer/client/query_tracker.h b/gpu/command_buffer/client/query_tracker.h
index 9df8d18..5341ae9 100644
--- a/gpu/command_buffer/client/query_tracker.h
+++ b/gpu/command_buffer/client/query_tracker.h
@@ -7,7 +7,7 @@
 
 #include <GLES2/gl2.h>
 
-#include <queue>
+#include <deque>
 #include "../client/hash_tables.h"
 #include "../common/gles2_cmd_format.h"
 #include "gles2_impl_export.h"
@@ -26,19 +26,30 @@ class GLES2_IMPL_EXPORT QuerySyncManager {
  public:
   static const size_t kSyncsPerBucket = 4096;
 
+  struct Bucket {
+    explicit Bucket(QuerySync* sync_mem)
+        : syncs(sync_mem),
+          used_query_count(0) {
+    }
+    QuerySync* syncs;
+    unsigned used_query_count;
+  };
   struct QueryInfo {
-    QueryInfo(int32 id, uint32 offset, QuerySync* sync_mem)
-        : shm_id(id),
+    QueryInfo(Bucket* bucket, int32 id, uint32 offset, QuerySync* sync_mem)
+        : bucket(bucket),
+          shm_id(id),
           shm_offset(offset),
           sync(sync_mem) {
     }
 
     QueryInfo()
-        : shm_id(0),
+        : bucket(NULL),
+          shm_id(0),
           shm_offset(0),
           sync(NULL) {
     }
 
+    Bucket* bucket;
     int32 shm_id;
     uint32 shm_offset;
     QuerySync* sync;
@@ -49,11 +60,12 @@ class GLES2_IMPL_EXPORT QuerySyncManager {
 
   bool Alloc(QueryInfo* info);
   void Free(const QueryInfo& sync);
+  void Shrink();
 
  private:
   MappedMemoryManager* mapped_memory_;
-  std::queue<QuerySync*> buckets_;
-  std::queue<QueryInfo> free_queries_;
+  std::deque<Bucket*> buckets_;
+  std::deque<QueryInfo> free_queries_;
 
   DISALLOW_COPY_AND_ASSIGN(QuerySyncManager);
 };
@@ -143,6 +155,7 @@ class GLES2_IMPL_EXPORT QueryTracker {
   Query* CreateQuery(GLuint id, GLenum target);
   Query* GetQuery(GLuint id);
   void RemoveQuery(GLuint id, bool context_lost);
+  void Shrink();
 
  private:
   typedef gpu::hash_map<GLuint, Query*> QueryMap;