gpu/command_buffer/service/context_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 "gpu/command_buffer/service/context_group.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "base/command_line.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/sys_info.h"
  13 #include "gpu/command_buffer/common/id_allocator.h"
  14 #include "gpu/command_buffer/service/buffer_manager.h"
  15 #include "gpu/command_buffer/service/framebuffer_manager.h"
  16 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
  17 #include "gpu/command_buffer/service/gpu_switches.h"
  18 #include "gpu/command_buffer/service/image_manager.h"
  19 #include "gpu/command_buffer/service/mailbox_manager.h"
  20 #include "gpu/command_buffer/service/memory_tracking.h"
  21 #include "gpu/command_buffer/service/program_manager.h"
  22 #include "gpu/command_buffer/service/renderbuffer_manager.h"
  23 #include "gpu/command_buffer/service/shader_manager.h"
  24 #include "gpu/command_buffer/service/texture_manager.h"
  25 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
  26 #include "ui/gl/gl_implementation.h"
  27
  28 namespace gpu {
  29 namespace gles2 {
  30
  31 ContextGroup::ContextGroup(
  32     MailboxManager* mailbox_manager,
  33     ImageManager* image_manager,
  34     MemoryTracker* memory_tracker,
  35     ShaderTranslatorCache* shader_translator_cache,
  36     FeatureInfo* feature_info,
  37     bool bind_generates_resource)
  38     : mailbox_manager_(mailbox_manager ? mailbox_manager : new MailboxManager),
  39       image_manager_(image_manager ? image_manager : new ImageManager),
  40       memory_tracker_(memory_tracker),
  41       shader_translator_cache_(shader_translator_cache),
  42       enforce_gl_minimums_(CommandLine::ForCurrentProcess()->HasSwitch(
  43           switches::kEnforceGLMinimums)),
  44       bind_generates_resource_(bind_generates_resource),
  45       max_vertex_attribs_(0u),
  46       max_texture_units_(0u),
  47       max_texture_image_units_(0u),
  48       max_vertex_texture_image_units_(0u),
  49       max_fragment_uniform_vectors_(0u),
  50       max_varying_vectors_(0u),
  51       max_vertex_uniform_vectors_(0u),
  52       max_color_attachments_(1u),
  53       max_draw_buffers_(1u),
  54       program_cache_(NULL),
  55       feature_info_(feature_info ? feature_info : new FeatureInfo),
  56       draw_buffer_(GL_BACK) {
  57   {
  58     TransferBufferManager* manager = new TransferBufferManager();
  59     transfer_buffer_manager_.reset(manager);
  60     manager->Initialize();
  61   }
  62
  63   id_namespaces_[id_namespaces::kBuffers].reset(new IdAllocator);
  64   id_namespaces_[id_namespaces::kFramebuffers].reset(new IdAllocator);
  65   id_namespaces_[id_namespaces::kProgramsAndShaders].reset(
  66       new NonReusedIdAllocator);
  67   id_namespaces_[id_namespaces::kRenderbuffers].reset(new IdAllocator);
  68   id_namespaces_[id_namespaces::kTextures].reset(new IdAllocator);
  69   id_namespaces_[id_namespaces::kQueries].reset(new IdAllocator);
  70   id_namespaces_[id_namespaces::kVertexArrays].reset(new IdAllocator);
  71 }
  72
  73 static void GetIntegerv(GLenum pname, uint32* var) {
  74   GLint value = 0;
  75   glGetIntegerv(pname, &value);
  76   *var = value;
  77 }
  78
  79 bool ContextGroup::Initialize(
  80     GLES2Decoder* decoder,
  81     const DisallowedFeatures& disallowed_features) {
  82   // If we've already initialized the group just add the context.
  83   if (HaveContexts()) {
  84     decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder));
  85     return true;
  86   }
  87
  88   if (!feature_info_->Initialize(disallowed_features)) {
  89     LOG(ERROR) << "ContextGroup::Initialize failed because FeatureInfo "
  90                << "initialization failed.";
  91     return false;
  92   }
  93
  94   const GLint kMinRenderbufferSize = 512;  // GL says 1 pixel!
  95   GLint max_renderbuffer_size = 0;
  96   if (!QueryGLFeature(
  97       GL_MAX_RENDERBUFFER_SIZE, kMinRenderbufferSize,
  98       &max_renderbuffer_size)) {
  99     LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
 100                << "renderbuffer size too small.";
 101     return false;
 102   }
 103   GLint max_samples = 0;
 104   if (feature_info_->feature_flags().chromium_framebuffer_multisample ||
 105       feature_info_->feature_flags().multisampled_render_to_texture) {
 106     if (feature_info_->feature_flags(
 107             ).use_img_for_multisampled_render_to_texture) {
 108       glGetIntegerv(GL_MAX_SAMPLES_IMG, &max_samples);
 109     } else {
 110       glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
 111     }
 112   }
 113
 114   if (feature_info_->feature_flags().ext_draw_buffers) {
 115     GetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &max_color_attachments_);
 116     if (max_color_attachments_ < 1)
 117       max_color_attachments_ = 1;
 118     GetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buffers_);
 119     if (max_draw_buffers_ < 1)
 120       max_draw_buffers_ = 1;
 121     draw_buffer_ = GL_BACK;
 122   }
 123
 124   const bool depth24_supported = feature_info_->feature_flags().oes_depth24;
 125
 126   buffer_manager_.reset(
 127       new BufferManager(memory_tracker_.get(), feature_info_.get()));
 128   framebuffer_manager_.reset(
 129       new FramebufferManager(max_draw_buffers_, max_color_attachments_));
 130   renderbuffer_manager_.reset(new RenderbufferManager(
 131       memory_tracker_.get(), max_renderbuffer_size, max_samples,
 132       depth24_supported));
 133   shader_manager_.reset(new ShaderManager());
 134
 135   // Lookup GL things we need to know.
 136   const GLint kGLES2RequiredMinimumVertexAttribs = 8u;
 137   if (!QueryGLFeatureU(
 138       GL_MAX_VERTEX_ATTRIBS, kGLES2RequiredMinimumVertexAttribs,
 139       &max_vertex_attribs_)) {
 140     LOG(ERROR) << "ContextGroup::Initialize failed because too few "
 141                << "vertex attributes supported.";
 142     return false;
 143   }
 144
 145   const GLuint kGLES2RequiredMinimumTextureUnits = 8u;
 146   if (!QueryGLFeatureU(
 147       GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, kGLES2RequiredMinimumTextureUnits,
 148       &max_texture_units_)) {
 149     LOG(ERROR) << "ContextGroup::Initialize failed because too few "
 150                << "texture units supported.";
 151     return false;
 152   }
 153
 154   GLint max_texture_size = 0;
 155   GLint max_cube_map_texture_size = 0;
 156   const GLint kMinTextureSize = 2048;  // GL actually says 64!?!?
 157   const GLint kMinCubeMapSize = 256;  // GL actually says 16!?!?
 158   if (!QueryGLFeature(
 159       GL_MAX_TEXTURE_SIZE, kMinTextureSize, &max_texture_size) ||
 160       !QueryGLFeature(
 161       GL_MAX_CUBE_MAP_TEXTURE_SIZE, kMinCubeMapSize,
 162       &max_cube_map_texture_size)) {
 163     LOG(ERROR) << "ContextGroup::Initialize failed because maximum texture size"
 164                << "is too small.";
 165     return false;
 166   }
 167
 168   if (feature_info_->workarounds().max_texture_size) {
 169     max_texture_size = std::min(
 170         max_texture_size, feature_info_->workarounds().max_texture_size);
 171   }
 172   if (feature_info_->workarounds().max_cube_map_texture_size) {
 173     max_cube_map_texture_size = std::min(
 174         max_cube_map_texture_size,
 175         feature_info_->workarounds().max_cube_map_texture_size);
 176   }
 177
 178   texture_manager_.reset(new TextureManager(memory_tracker_.get(),
 179                                             feature_info_.get(),
 180                                             max_texture_size,
 181                                             max_cube_map_texture_size,
 182                                             bind_generates_resource_));
 183   texture_manager_->set_framebuffer_manager(framebuffer_manager_.get());
 184
 185   const GLint kMinTextureImageUnits = 8;
 186   const GLint kMinVertexTextureImageUnits = 0;
 187   if (!QueryGLFeatureU(
 188       GL_MAX_TEXTURE_IMAGE_UNITS, kMinTextureImageUnits,
 189       &max_texture_image_units_) ||
 190       !QueryGLFeatureU(
 191       GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, kMinVertexTextureImageUnits,
 192       &max_vertex_texture_image_units_)) {
 193     LOG(ERROR) << "ContextGroup::Initialize failed because too few "
 194                << "texture units.";
 195     return false;
 196   }
 197
 198   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
 199     GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS,
 200         &max_fragment_uniform_vectors_);
 201     GetIntegerv(GL_MAX_VARYING_VECTORS, &max_varying_vectors_);
 202     GetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &max_vertex_uniform_vectors_);
 203   } else {
 204     GetIntegerv(
 205         GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max_fragment_uniform_vectors_);
 206     max_fragment_uniform_vectors_ /= 4;
 207     GetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_vectors_);
 208     max_varying_vectors_ /= 4;
 209     GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &max_vertex_uniform_vectors_);
 210     max_vertex_uniform_vectors_ /= 4;
 211   }
 212
 213   const GLint kMinFragmentUniformVectors = 16;
 214   const GLint kMinVaryingVectors = 8;
 215   const GLint kMinVertexUniformVectors = 128;
 216   if (!CheckGLFeatureU(
 217       kMinFragmentUniformVectors, &max_fragment_uniform_vectors_) ||
 218       !CheckGLFeatureU(kMinVaryingVectors, &max_varying_vectors_) ||
 219       !CheckGLFeatureU(
 220       kMinVertexUniformVectors, &max_vertex_uniform_vectors_)) {
 221     LOG(ERROR) << "ContextGroup::Initialize failed because too few "
 222                << "uniforms or varyings supported.";
 223     return false;
 224   }
 225
 226   // Some shaders in Skia need more than the min available vertex and
 227   // fragment shader uniform vectors in case of OSMesa GL Implementation
 228   if (feature_info_->workarounds().max_fragment_uniform_vectors) {
 229     max_fragment_uniform_vectors_ = std::min(
 230         max_fragment_uniform_vectors_,
 231         static_cast<uint32>(
 232             feature_info_->workarounds().max_fragment_uniform_vectors));
 233   }
 234   if (feature_info_->workarounds().max_varying_vectors) {
 235     max_varying_vectors_ = std::min(
 236         max_varying_vectors_,
 237         static_cast<uint32>(feature_info_->workarounds().max_varying_vectors));
 238   }
 239   if (feature_info_->workarounds().max_vertex_uniform_vectors) {
 240     max_vertex_uniform_vectors_ =
 241         std::min(max_vertex_uniform_vectors_,
 242                  static_cast<uint32>(
 243                      feature_info_->workarounds().max_vertex_uniform_vectors));
 244   }
 245
 246   program_manager_.reset(new ProgramManager(
 247       program_cache_, max_varying_vectors_));
 248
 249   if (!texture_manager_->Initialize()) {
 250     LOG(ERROR) << "Context::Group::Initialize failed because texture manager "
 251                << "failed to initialize.";
 252     return false;
 253   }
 254
 255   decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder));
 256   return true;
 257 }
 258
 259 namespace {
 260
 261 bool IsNull(const base::WeakPtr<gles2::GLES2Decoder>& decoder) {
 262   return !decoder.get();
 263 }
 264
 265 template <typename T>
 266 class WeakPtrEquals {
 267  public:
 268   explicit WeakPtrEquals(T* t) : t_(t) {}
 269
 270   bool operator()(const base::WeakPtr<T>& t) {
 271     return t.get() == t_;
 272   }
 273
 274  private:
 275   T* const t_;
 276 };
 277
 278 }  // namespace anonymous
 279
 280 bool ContextGroup::HaveContexts() {
 281   decoders_.erase(std::remove_if(decoders_.begin(), decoders_.end(), IsNull),
 282                   decoders_.end());
 283   return !decoders_.empty();
 284 }
 285
 286 void ContextGroup::Destroy(GLES2Decoder* decoder, bool have_context) {
 287   decoders_.erase(std::remove_if(decoders_.begin(), decoders_.end(),
 288                                  WeakPtrEquals<gles2::GLES2Decoder>(decoder)),
 289                   decoders_.end());
 290   // If we still have contexts do nothing.
 291   if (HaveContexts()) {
 292     return;
 293   }
 294
 295   if (buffer_manager_ != NULL) {
 296     buffer_manager_->Destroy(have_context);
 297     buffer_manager_.reset();
 298   }
 299
 300   if (framebuffer_manager_ != NULL) {
 301     framebuffer_manager_->Destroy(have_context);
 302     if (texture_manager_)
 303       texture_manager_->set_framebuffer_manager(NULL);
 304     framebuffer_manager_.reset();
 305   }
 306
 307   if (renderbuffer_manager_ != NULL) {
 308     renderbuffer_manager_->Destroy(have_context);
 309     renderbuffer_manager_.reset();
 310   }
 311
 312   if (texture_manager_ != NULL) {
 313     texture_manager_->Destroy(have_context);
 314     texture_manager_.reset();
 315   }
 316
 317   if (program_manager_ != NULL) {
 318     program_manager_->Destroy(have_context);
 319     program_manager_.reset();
 320   }
 321
 322   if (shader_manager_ != NULL) {
 323     shader_manager_->Destroy(have_context);
 324     shader_manager_.reset();
 325   }
 326
 327   memory_tracker_ = NULL;
 328 }
 329
 330 IdAllocatorInterface* ContextGroup::GetIdAllocator(unsigned namespace_id) {
 331   if (namespace_id >= arraysize(id_namespaces_))
 332     return NULL;
 333
 334   return id_namespaces_[namespace_id].get();
 335 }
 336
 337 uint32 ContextGroup::GetMemRepresented() const {
 338   uint32 total = 0;
 339   if (buffer_manager_.get())
 340     total += buffer_manager_->mem_represented();
 341   if (renderbuffer_manager_.get())
 342     total += renderbuffer_manager_->mem_represented();
 343   if (texture_manager_.get())
 344     total += texture_manager_->mem_represented();
 345   return total;
 346 }
 347
 348 void ContextGroup::LoseContexts(GLenum reset_status) {
 349   for (size_t ii = 0; ii < decoders_.size(); ++ii) {
 350     if (decoders_[ii].get()) {
 351       decoders_[ii]->LoseContext(reset_status);
 352     }
 353   }
 354 }
 355
 356 ContextGroup::~ContextGroup() {
 357   CHECK(!HaveContexts());
 358 }
 359
 360 bool ContextGroup::CheckGLFeature(GLint min_required, GLint* v) {
 361   GLint value = *v;
 362   if (enforce_gl_minimums_) {
 363     value = std::min(min_required, value);
 364   }
 365   *v = value;
 366   return value >= min_required;
 367 }
 368
 369 bool ContextGroup::CheckGLFeatureU(GLint min_required, uint32* v) {
 370   GLint value = *v;
 371   if (enforce_gl_minimums_) {
 372     value = std::min(min_required, value);
 373   }
 374   *v = value;
 375   return value >= min_required;
 376 }
 377
 378 bool ContextGroup::QueryGLFeature(
 379     GLenum pname, GLint min_required, GLint* v) {
 380   GLint value = 0;
 381   glGetIntegerv(pname, &value);
 382   *v = value;
 383   return CheckGLFeature(min_required, v);
 384 }
 385
 386 bool ContextGroup::QueryGLFeatureU(
 387     GLenum pname, GLint min_required, uint32* v) {
 388   uint32 value = 0;
 389   GetIntegerv(pname, &value);
 390   bool result = CheckGLFeatureU(min_required, &value);
 391   *v = value;
 392   return result;
 393 }
 394
 395 }  // namespace gles2
 396 }  // namespace gpu