gpu/command_buffer/client/query_tracker.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef GPU_COMMAND_BUFFER_CLIENT_QUERY_TRACKER_H_
   6 #define GPU_COMMAND_BUFFER_CLIENT_QUERY_TRACKER_H_
   7
   8 #include <GLES2/gl2.h>
   9
  10 #include <bitset>
  11 #include <deque>
  12 #include <list>
  13
  14 #include "base/atomicops.h"
  15 #include "base/containers/hash_tables.h"
  16 #include "gles2_impl_export.h"
  17 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  18
  19 namespace gpu {
  20
  21 class CommandBufferHelper;
  22 class MappedMemoryManager;
  23
  24 namespace gles2 {
  25
  26 class GLES2Implementation;
  27
  28 // Manages buckets of QuerySync instances in mapped memory.
  29 class GLES2_IMPL_EXPORT QuerySyncManager {
  30  public:
  31   static const size_t kSyncsPerBucket = 256;
  32
  33   struct Bucket {
  34     Bucket(QuerySync* sync_mem, int32 shm_id, uint32 shm_offset);
  35     ~Bucket();
  36     QuerySync* syncs;
  37     int32 shm_id;
  38     uint32 base_shm_offset;
  39     std::bitset<kSyncsPerBucket> in_use_queries;
  40   };
  41   struct QueryInfo {
  42     QueryInfo(Bucket* bucket, int32 id, uint32 offset, QuerySync* sync_mem)
  43         : bucket(bucket),
  44           shm_id(id),
  45           shm_offset(offset),
  46           sync(sync_mem) {
  47     }
  48
  49     QueryInfo()
  50         : bucket(NULL),
  51           shm_id(0),
  52           shm_offset(0),
  53           sync(NULL) {
  54     }
  55
  56     Bucket* bucket;
  57     int32 shm_id;
  58     uint32 shm_offset;
  59     QuerySync* sync;
  60   };
  61
  62   explicit QuerySyncManager(MappedMemoryManager* manager);
  63   ~QuerySyncManager();
  64
  65   bool Alloc(QueryInfo* info);
  66   void Free(const QueryInfo& sync);
  67   void Shrink();
  68
  69  private:
  70   MappedMemoryManager* mapped_memory_;
  71   std::deque<Bucket*> buckets_;
  72
  73   DISALLOW_COPY_AND_ASSIGN(QuerySyncManager);
  74 };
  75
  76 // Tracks queries for client side of command buffer.
  77 class GLES2_IMPL_EXPORT QueryTracker {
  78  public:
  79   class GLES2_IMPL_EXPORT Query {
  80    public:
  81     enum State {
  82       kUninitialized,  // never used
  83       kActive,         // between begin - end
  84       kPending,        // not yet complete
  85       kComplete        // completed
  86     };
  87
  88     Query(GLuint id, GLenum target, const QuerySyncManager::QueryInfo& info);
  89
  90     GLenum target() const {
  91       return target_;
  92     }
  93
  94     GLenum id() const {
  95       return id_;
  96     }
  97
  98     int32 shm_id() const {
  99       return info_.shm_id;
 100     }
 101
 102     uint32 shm_offset() const {
 103       return info_.shm_offset;
 104     }
 105
 106     void MarkAsActive() {
 107       state_ = kActive;
 108       ++submit_count_;
 109       if (submit_count_ == INT_MAX)
 110         submit_count_ = 1;
 111     }
 112
 113     void MarkAsPending(int32 token) {
 114       token_ = token;
 115       state_ = kPending;
 116     }
 117
 118     base::subtle::Atomic32 submit_count() const { return submit_count_; }
 119
 120     int32 token() const {
 121       return token_;
 122     }
 123
 124     bool NeverUsed() const {
 125       return state_ == kUninitialized;
 126     }
 127
 128     bool Pending() const {
 129       return state_ == kPending;
 130     }
 131
 132     bool CheckResultsAvailable(CommandBufferHelper* helper);
 133
 134     uint32 GetResult() const;
 135
 136     void Begin(GLES2Implementation* gl);
 137     void End(GLES2Implementation* gl);
 138
 139    private:
 140     friend class QueryTracker;
 141     friend class QueryTrackerTest;
 142
 143     GLuint id_;
 144     GLenum target_;
 145     QuerySyncManager::QueryInfo info_;
 146     State state_;
 147     base::subtle::Atomic32 submit_count_;
 148     int32 token_;
 149     uint32 flush_count_;
 150     uint64 client_begin_time_us_; // Only used for latency query target.
 151     uint32 result_;
 152   };
 153
 154   QueryTracker(MappedMemoryManager* manager);
 155   ~QueryTracker();
 156
 157   Query* CreateQuery(GLuint id, GLenum target);
 158   Query* GetQuery(GLuint id);
 159   void RemoveQuery(GLuint id);
 160   void Shrink();
 161   void FreeCompletedQueries();
 162
 163  private:
 164   typedef base::hash_map<GLuint, Query*> QueryMap;
 165   typedef std::list<Query*> QueryList;
 166
 167   QueryMap queries_;
 168   QueryList removed_queries_;
 169   QuerySyncManager query_sync_manager_;
 170
 171   DISALLOW_COPY_AND_ASSIGN(QueryTracker);
 172 };
 173
 174 }  // namespace gles2
 175 }  // namespace gpu
 176
 177 #endif  // GPU_COMMAND_BUFFER_CLIENT_QUERY_TRACKER_H_