gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/client/buffer_tracker.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_BUFFER_TRACKER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_BUFFER_TRACKER_H_
 
 #include <GLES2/gl2.h>
 
 #include <queue>
@@ skipping 17 matching lines @@
            unsigned int size,
            int32 shm_id,
            uint32 shm_offset,
            void* address)
         : id_(id),
           size_(size),
           shm_id_(shm_id),
           shm_offset_(shm_offset),
           address_(address),
           mapped_(false),
-          transfer_ready_token_(0) {
+          last_usage_token_(0),
+          async_token_(0) {
     }
 
     GLenum id() const {
       return id_;
     }
 
     unsigned int size() const {
       return size_;
     }
 
@@ skipping 10 matching lines @@
     }
 
     void set_mapped(bool mapped) {
       mapped_ = mapped;
     }
 
     bool mapped() const {
       return mapped_;
     }
 
-    void set_transfer_ready_token(int token) {
-      transfer_ready_token_ = token;
+    void set_last_usage_token(int token) {
+      last_usage_token_ = token;
     }
 
-    uint32 transfer_ready_token() const {
-      return transfer_ready_token_;
+    int last_usage_token() const {
+      return last_usage_token_;
+    }
+
+    void set_async_token(uint32 async_token) {
+      async_token_ = async_token;
+    }
+
+    GLuint async_token() const {
+      return async_token_;
     }
 
    private:
     friend class BufferTracker;
     friend class BufferTrackerTest;
 
     GLuint id_;
     unsigned int size_;
     int32 shm_id_;
     uint32 shm_offset_;
     void* address_;
     bool mapped_;
-    int32 transfer_ready_token_;
+    int32 last_usage_token_;
+    GLuint async_token_;

[reveman, 2014/01/22 17:30:04]

GLuint? "int32 last_async_usage_token_;" instead?

[jadahl, 2014/01/23 10:24:06]

According to what I read in the code, negative tokens are used for reporting
errors. Async tokens does not deal with errors as it is now, and thus doesn't
need to be signed. It should be uint32 instead of GLuint though. GLuint is a
left-over from when |async_token_| was |async_query_id_|.

   };
 
   BufferTracker(MappedMemoryManager* manager);
   ~BufferTracker();
 
   Buffer* CreateBuffer(GLuint id, GLsizeiptr size);
   Buffer* GetBuffer(GLuint id);
   void RemoveBuffer(GLuint id);
 
   // Frees the block of memory associated with buffer, pending the passage
   // of a token.
-  void FreePendingToken(Buffer*, int32 token);
+  void FreePendingToken(Buffer* buffer, int32 token);
+  void FreePendingAsyncToken(Buffer* buffer, uint32 async_token);
+  void Free(Buffer* buffer);
 
  private:
   typedef base::hash_map<GLuint, Buffer*> BufferMap;
 
   MappedMemoryManager* mapped_memory_;
   BufferMap buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferTracker);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_BUFFER_TRACKER_H_