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     GLuint 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 Active() const {
 129       return state_ == kActive;
 130     }
 131
 132     bool Pending() const {
 133       return state_ == kPending;
 134     }
 135
 136     bool CheckResultsAvailable(CommandBufferHelper* helper);
 137
 138     uint64 GetResult() const;
 139
 140    private:
 141     friend class QueryTracker;
 142     friend class QueryTrackerTest;
 143
 144     void Begin(GLES2Implementation* gl);
 145     void End(GLES2Implementation* gl);
 146     void QueryCounter(GLES2Implementation* gl);
 147
 148     GLuint id_;
 149     GLenum target_;
 150     QuerySyncManager::QueryInfo info_;
 151     State state_;
 152     base::subtle::Atomic32 submit_count_;
 153     int32 token_;
 154     uint32 flush_count_;
 155     uint64 client_begin_time_us_; // Only used for latency query target.
 156     uint64 result_;
 157   };
 158
 159   QueryTracker(MappedMemoryManager* manager);
 160   ~QueryTracker();
 161
 162   Query* CreateQuery(GLuint id, GLenum target);
 163   Query* GetQuery(GLuint id);
 164   Query* GetCurrentQuery(GLenum target);
 165   void RemoveQuery(GLuint id);
 166   void Shrink();
 167   void FreeCompletedQueries();
 168
 169   bool BeginQuery(GLuint id, GLenum target, GLES2Implementation* gl);
 170   bool EndQuery(GLenum target, GLES2Implementation* gl);
 171   bool QueryCounter(GLuint id, GLenum target, GLES2Implementation* gl);
 172
 173  private:
 174   typedef base::hash_map<GLuint, Query*> QueryIdMap;
 175   typedef base::hash_map<GLenum, Query*> QueryTargetMap;
 176   typedef std::list<Query*> QueryList;
 177
 178   QueryIdMap queries_;
 179   QueryTargetMap current_queries_;
 180   QueryList removed_queries_;
 181   QuerySyncManager query_sync_manager_;
 182
 183   DISALLOW_COPY_AND_ASSIGN(QueryTracker);
 184 };
 185
 186 }  // namespace gles2
 187 }  // namespace gpu
 188
 189 #endif  // GPU_COMMAND_BUFFER_CLIENT_QUERY_TRACKER_H_