gpu/command_buffer/client/share_group.cc

   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 #include <stack>
   6 #include <vector>
   7
   8 #include "gpu/command_buffer/client/share_group.h"
   9
  10 #include "base/logging.h"
  11 #include "base/synchronization/lock.h"
  12 #include "gpu/command_buffer/client/gles2_implementation.h"
  13 #include "gpu/command_buffer/client/program_info_manager.h"
  14 #include "gpu/command_buffer/common/id_allocator.h"
  15
  16 namespace gpu {
  17 namespace gles2 {
  18
  19 ShareGroupContextData::IdHandlerData::IdHandlerData() : flush_generation_(0) {}
  20 ShareGroupContextData::IdHandlerData::~IdHandlerData() {}
  21
  22 COMPILE_ASSERT(gpu::kInvalidResource == 0,
  23                INVALID_RESOURCE_NOT_0_AS_GL_EXPECTS);
  24
  25 // The standard id handler.
  26 class IdHandler : public IdHandlerInterface {
  27  public:
  28   IdHandler() { }
  29   virtual ~IdHandler() { }
  30
  31   // Overridden from IdHandlerInterface.
  32   virtual void MakeIds(
  33       GLES2Implementation* /* gl_impl */,
  34       GLuint id_offset, GLsizei n, GLuint* ids) OVERRIDE {
  35     base::AutoLock auto_lock(lock_);
  36     if (id_offset == 0) {
  37       for (GLsizei ii = 0; ii < n; ++ii) {
  38         ids[ii] = id_allocator_.AllocateID();
  39       }
  40     } else {
  41       for (GLsizei ii = 0; ii < n; ++ii) {
  42         ids[ii] = id_allocator_.AllocateIDAtOrAbove(id_offset);
  43         id_offset = ids[ii] + 1;
  44       }
  45     }
  46   }
  47
  48   // Overridden from IdHandlerInterface.
  49   virtual bool FreeIds(
  50       GLES2Implementation* gl_impl,
  51       GLsizei n, const GLuint* ids, DeleteFn delete_fn) OVERRIDE {
  52     base::AutoLock auto_lock(lock_);
  53
  54     for (GLsizei ii = 0; ii < n; ++ii) {
  55       id_allocator_.FreeID(ids[ii]);
  56     }
  57
  58     (gl_impl->*delete_fn)(n, ids);
  59     // We need to ensure that the delete call is evaluated on the service side
  60     // before any other contexts issue commands using these client ids.
  61     // TODO(vmiura): Can remove this by virtualizing internal ids, however
  62     // this code only affects PPAPI for now.
  63     gl_impl->helper()->CommandBufferHelper::Flush();
  64     return true;
  65   }
  66
  67   // Overridden from IdHandlerInterface.
  68   virtual bool MarkAsUsedForBind(GLuint id) OVERRIDE {
  69     if (id == 0)
  70       return true;
  71     base::AutoLock auto_lock(lock_);
  72     return id_allocator_.MarkAsUsed(id);
  73   }
  74
  75   virtual void FreeContext(GLES2Implementation* gl_impl) OVERRIDE {}
  76
  77  private:
  78   base::Lock lock_;
  79   IdAllocator id_allocator_;
  80 };
  81
  82 // An id handler that requires Gen before Bind.
  83 class StrictIdHandler : public IdHandlerInterface {
  84  public:
  85   explicit StrictIdHandler(int id_namespace) : id_namespace_(id_namespace) {}
  86   virtual ~StrictIdHandler() {}
  87
  88   // Overridden from IdHandler.
  89   virtual void MakeIds(GLES2Implementation* gl_impl,
  90                        GLuint /* id_offset */,
  91                        GLsizei n,
  92                        GLuint* ids) OVERRIDE {
  93     base::AutoLock auto_lock(lock_);
  94
  95     // Collect pending FreeIds from other flush_generation.
  96     CollectPendingFreeIds(gl_impl);
  97
  98     for (GLsizei ii = 0; ii < n; ++ii) {
  99       if (!free_ids_.empty()) {
 100         // Allocate a previously freed Id.
 101         ids[ii] = free_ids_.top();
 102         free_ids_.pop();
 103
 104         // Record kIdInUse state.
 105         DCHECK(id_states_[ids[ii] - 1] == kIdFree);
 106         id_states_[ids[ii] - 1] = kIdInUse;
 107       } else {
 108         // Allocate a new Id.
 109         id_states_.push_back(kIdInUse);
 110         ids[ii] = id_states_.size();
 111       }
 112     }
 113   }
 114
 115   // Overridden from IdHandler.
 116   virtual bool FreeIds(GLES2Implementation* gl_impl,
 117                        GLsizei n,
 118                        const GLuint* ids,
 119                        DeleteFn delete_fn) OVERRIDE {
 120
 121     // Delete stub must run before CollectPendingFreeIds.
 122     (gl_impl->*delete_fn)(n, ids);
 123
 124     {
 125       base::AutoLock auto_lock(lock_);
 126
 127       // Collect pending FreeIds from other flush_generation.
 128       CollectPendingFreeIds(gl_impl);
 129
 130       // Save Ids to free in a later flush_generation.
 131       ShareGroupContextData::IdHandlerData* ctxt_data =
 132           gl_impl->share_group_context_data()->id_handler_data(id_namespace_);
 133
 134       for (GLsizei ii = 0; ii < n; ++ii) {
 135         GLuint id = ids[ii];
 136         if (id != 0) {
 137           // Save freed Id for later.
 138           DCHECK(id_states_[id - 1] == kIdInUse);
 139           id_states_[id - 1] = kIdPendingFree;
 140           ctxt_data->freed_ids_.push_back(id);
 141         }
 142       }
 143     }
 144
 145     return true;
 146   }
 147
 148   // Overridden from IdHandler.
 149   virtual bool MarkAsUsedForBind(GLuint id) OVERRIDE {
 150 #ifndef NDEBUG
 151     if (id != 0) {
 152       base::AutoLock auto_lock(lock_);
 153       DCHECK(id_states_[id - 1] == kIdInUse);
 154     }
 155 #endif
 156     return true;
 157   }
 158
 159   // Overridden from IdHandlerInterface.
 160   virtual void FreeContext(GLES2Implementation* gl_impl) OVERRIDE {
 161     base::AutoLock auto_lock(lock_);
 162     CollectPendingFreeIds(gl_impl);
 163   }
 164
 165  private:
 166   enum IdState { kIdFree, kIdPendingFree, kIdInUse };
 167
 168   void CollectPendingFreeIds(GLES2Implementation* gl_impl) {
 169     uint32 flush_generation = gl_impl->helper()->flush_generation();
 170     ShareGroupContextData::IdHandlerData* ctxt_data =
 171         gl_impl->share_group_context_data()->id_handler_data(id_namespace_);
 172
 173     if (ctxt_data->flush_generation_ != flush_generation) {
 174       ctxt_data->flush_generation_ = flush_generation;
 175       for (uint32 ii = 0; ii < ctxt_data->freed_ids_.size(); ++ii) {
 176         const GLuint id = ctxt_data->freed_ids_[ii];
 177         DCHECK(id_states_[id - 1] == kIdPendingFree);
 178         id_states_[id - 1] = kIdFree;
 179         free_ids_.push(id);
 180       }
 181       ctxt_data->freed_ids_.clear();
 182     }
 183   }
 184
 185   int id_namespace_;
 186
 187   base::Lock lock_;
 188   std::vector<uint8> id_states_;
 189   std::stack<uint32> free_ids_;
 190 };
 191
 192 // An id handler for ids that are never reused.
 193 class NonReusedIdHandler : public IdHandlerInterface {
 194  public:
 195   NonReusedIdHandler() : last_id_(0) {}
 196   virtual ~NonReusedIdHandler() {}
 197
 198   // Overridden from IdHandlerInterface.
 199   virtual void MakeIds(
 200       GLES2Implementation* /* gl_impl */,
 201       GLuint id_offset, GLsizei n, GLuint* ids) OVERRIDE {
 202     base::AutoLock auto_lock(lock_);
 203     for (GLsizei ii = 0; ii < n; ++ii) {
 204       ids[ii] = ++last_id_ + id_offset;
 205     }
 206   }
 207
 208   // Overridden from IdHandlerInterface.
 209   virtual bool FreeIds(
 210       GLES2Implementation* gl_impl,
 211       GLsizei n, const GLuint* ids, DeleteFn delete_fn) OVERRIDE {
 212     // Ids are never freed.
 213     (gl_impl->*delete_fn)(n, ids);
 214     return true;
 215   }
 216
 217   // Overridden from IdHandlerInterface.
 218   virtual bool MarkAsUsedForBind(GLuint /* id */) OVERRIDE {
 219     // This is only used for Shaders and Programs which have no bind.
 220     return false;
 221   }
 222
 223   virtual void FreeContext(GLES2Implementation* gl_impl) OVERRIDE {}
 224
 225  private:
 226   base::Lock lock_;
 227   GLuint last_id_;
 228 };
 229
 230 ShareGroup::ShareGroup(bool bind_generates_resource)
 231     : bind_generates_resource_(bind_generates_resource) {
 232   if (bind_generates_resource) {
 233     for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
 234       if (i == id_namespaces::kProgramsAndShaders) {
 235         id_handlers_[i].reset(new NonReusedIdHandler());
 236       } else {
 237         id_handlers_[i].reset(new IdHandler());
 238       }
 239     }
 240   } else {
 241     for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
 242       if (i == id_namespaces::kProgramsAndShaders) {
 243         id_handlers_[i].reset(new NonReusedIdHandler());
 244       } else {
 245         id_handlers_[i].reset(new StrictIdHandler(i));
 246       }
 247     }
 248   }
 249   program_info_manager_.reset(ProgramInfoManager::Create(false));
 250 }
 251
 252 void ShareGroup::set_program_info_manager(ProgramInfoManager* manager) {
 253   program_info_manager_.reset(manager);
 254 }
 255
 256 ShareGroup::~ShareGroup() {}
 257
 258 }  // namespace gles2
 259 }  // namespace gpu