Home | History | Annotate | Download | only in client 
      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 <deque>
     11 #include <list>
     12 
     13 #include "base/atomicops.h"
     14 #include "base/containers/hash_tables.h"
     15 #include "gles2_impl_export.h"
     16 #include "gpu/command_buffer/common/gles2_cmd_format.h"
     17 
     18 namespace gpu {
     19 
     20 class CommandBufferHelper;
     21 class MappedMemoryManager;
     22 
     23 namespace gles2 {
     24 
     25 class GLES2Implementation;
     26 
     27 // Manages buckets of QuerySync instances in mapped memory.
     28 class GLES2_IMPL_EXPORT QuerySyncManager {
     29  public:
     30   static const size_t kSyncsPerBucket = 4096;
     31 
     32   struct Bucket {
     33     explicit Bucket(QuerySync* sync_mem)
     34         : syncs(sync_mem),
     35           used_query_count(0) {
     36     }
     37     QuerySync* syncs;
     38     unsigned used_query_count;
     39   };
     40   struct QueryInfo {
     41     QueryInfo(Bucket* bucket, int32 id, uint32 offset, QuerySync* sync_mem)
     42         : bucket(bucket),
     43           shm_id(id),
     44           shm_offset(offset),
     45           sync(sync_mem) {
     46     }
     47 
     48     QueryInfo()
     49         : bucket(NULL),
     50           shm_id(0),
     51           shm_offset(0),
     52           sync(NULL) {
     53     }
     54 
     55     Bucket* bucket;
     56     int32 shm_id;
     57     uint32 shm_offset;
     58     QuerySync* sync;
     59   };
     60 
     61   explicit QuerySyncManager(MappedMemoryManager* manager);
     62   ~QuerySyncManager();
     63 
     64   bool Alloc(QueryInfo* info);
     65   void Free(const QueryInfo& sync);
     66   void Shrink();
     67 
     68  private:
     69   MappedMemoryManager* mapped_memory_;
     70   std::deque<Bucket*> buckets_;
     71   std::deque<QueryInfo> free_queries_;
     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_
    178