gpu/command_buffer/service/buffer_manager.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/buffer_manager.h"
   6 #include <limits>
   7 #include "base/logging.h"
   8 #include "base/trace_event/trace_event.h"
   9 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  10 #include "gpu/command_buffer/service/context_state.h"
  11 #include "gpu/command_buffer/service/error_state.h"
  12 #include "gpu/command_buffer/service/feature_info.h"
  13 #include "gpu/command_buffer/service/memory_tracking.h"
  14 #include "ui/gl/gl_bindings.h"
  15 #include "ui/gl/gl_implementation.h"
  16
  17 namespace gpu {
  18 namespace gles2 {
  19
  20 BufferManager::BufferManager(
  21     MemoryTracker* memory_tracker,
  22     FeatureInfo* feature_info)
  23     : memory_tracker_(
  24           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
  25       feature_info_(feature_info),
  26       allow_buffers_on_multiple_targets_(false),
  27       allow_fixed_attribs_(false),
  28       buffer_count_(0),
  29       have_context_(true),
  30       use_client_side_arrays_for_stream_buffers_(
  31           feature_info ? feature_info->workarounds(
  32               ).use_client_side_arrays_for_stream_buffers : 0) {
  33 }
  34
  35 BufferManager::~BufferManager() {
  36   DCHECK(buffers_.empty());
  37   CHECK_EQ(buffer_count_, 0u);
  38 }
  39
  40 void BufferManager::Destroy(bool have_context) {
  41   have_context_ = have_context;
  42   buffers_.clear();
  43   DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
  44 }
  45
  46 void BufferManager::CreateBuffer(GLuint client_id, GLuint service_id) {
  47   scoped_refptr<Buffer> buffer(new Buffer(this, service_id));
  48   std::pair<BufferMap::iterator, bool> result =
  49       buffers_.insert(std::make_pair(client_id, buffer));
  50   DCHECK(result.second);
  51 }
  52
  53 Buffer* BufferManager::GetBuffer(
  54     GLuint client_id) {
  55   BufferMap::iterator it = buffers_.find(client_id);
  56   return it != buffers_.end() ? it->second.get() : NULL;
  57 }
  58
  59 void BufferManager::RemoveBuffer(GLuint client_id) {
  60   BufferMap::iterator it = buffers_.find(client_id);
  61   if (it != buffers_.end()) {
  62     Buffer* buffer = it->second.get();
  63     buffer->MarkAsDeleted();
  64     buffers_.erase(it);
  65   }
  66 }
  67
  68 void BufferManager::StartTracking(Buffer* /* buffer */) {
  69   ++buffer_count_;
  70 }
  71
  72 void BufferManager::StopTracking(Buffer* buffer) {
  73   memory_tracker_->TrackMemFree(buffer->size());
  74   --buffer_count_;
  75 }
  76
  77 Buffer::MappedRange::MappedRange(
  78     GLintptr offset, GLsizeiptr size, GLenum access, void* pointer,
  79     scoped_refptr<gpu::Buffer> shm)
  80     : offset(offset),
  81       size(size),
  82       access(access),
  83       pointer(pointer),
  84       shm(shm) {
  85   DCHECK(pointer);
  86   DCHECK(shm.get() && GetShmPointer());
  87 }
  88
  89 Buffer::MappedRange::~MappedRange() {
  90 }
  91
  92 void* Buffer::MappedRange::GetShmPointer() const {
  93   DCHECK(shm.get());
  94   return shm->GetDataAddress(static_cast<unsigned int>(offset),
  95                              static_cast<unsigned int>(size));
  96 }
  97
  98 Buffer::Buffer(BufferManager* manager, GLuint service_id)
  99     : manager_(manager),
 100       size_(0),
 101       deleted_(false),
 102       shadowed_(false),
 103       is_client_side_array_(false),
 104       service_id_(service_id),
 105       target_(0),
 106       usage_(GL_STATIC_DRAW) {
 107   manager_->StartTracking(this);
 108 }
 109
 110 Buffer::~Buffer() {
 111   if (manager_) {
 112     if (manager_->have_context_) {
 113       GLuint id = service_id();
 114       glDeleteBuffersARB(1, &id);
 115     }
 116     manager_->StopTracking(this);
 117     manager_ = NULL;
 118   }
 119 }
 120
 121 void Buffer::SetInfo(
 122     GLsizeiptr size, GLenum usage, bool shadow, const GLvoid* data,
 123     bool is_client_side_array) {
 124   usage_ = usage;
 125   is_client_side_array_ = is_client_side_array;
 126   ClearCache();
 127   if (size != size_ || shadow != shadowed_) {
 128     shadowed_ = shadow;
 129     size_ = size;
 130     if (shadowed_) {
 131       shadow_.reset(new int8[size]);
 132     } else {
 133       shadow_.reset();
 134     }
 135   }
 136   if (shadowed_) {
 137     if (data) {
 138       memcpy(shadow_.get(), data, size);
 139     } else {
 140       memset(shadow_.get(), 0, size);
 141     }
 142   }
 143   mapped_range_.reset(nullptr);
 144 }
 145
 146 bool Buffer::CheckRange(
 147     GLintptr offset, GLsizeiptr size) const {
 148   int32 end = 0;
 149   return offset >= 0 && size >= 0 &&
 150          offset <= std::numeric_limits<int32>::max() &&
 151          size <= std::numeric_limits<int32>::max() &&
 152          SafeAddInt32(offset, size, &end) && end <= size_;
 153 }
 154
 155 bool Buffer::SetRange(
 156     GLintptr offset, GLsizeiptr size, const GLvoid * data) {
 157   if (!CheckRange(offset, size)) {
 158     return false;
 159   }
 160   if (shadowed_) {
 161     memcpy(shadow_.get() + offset, data, size);
 162     ClearCache();
 163   }
 164   return true;
 165 }
 166
 167 const void* Buffer::GetRange(
 168     GLintptr offset, GLsizeiptr size) const {
 169   if (!shadowed_) {
 170     return NULL;
 171   }
 172   if (!CheckRange(offset, size)) {
 173     return NULL;
 174   }
 175   return shadow_.get() + offset;
 176 }
 177
 178 void Buffer::ClearCache() {
 179   range_set_.clear();
 180 }
 181
 182 template <typename T>
 183 GLuint GetMaxValue(const void* data, GLuint offset, GLsizei count) {
 184   GLuint max_value = 0;
 185   const T* element = reinterpret_cast<const T*>(
 186       static_cast<const int8*>(data) + offset);
 187   const T* end = element + count;
 188   for (; element < end; ++element) {
 189     if (*element > max_value) {
 190       max_value = *element;
 191     }
 192   }
 193   return max_value;
 194 }
 195
 196 bool Buffer::GetMaxValueForRange(
 197     GLuint offset, GLsizei count, GLenum type, GLuint* max_value) {
 198   Range range(offset, count, type);
 199   RangeToMaxValueMap::iterator it = range_set_.find(range);
 200   if (it != range_set_.end()) {
 201     *max_value = it->second;
 202     return true;
 203   }
 204
 205   uint32 size;
 206   if (!SafeMultiplyUint32(
 207       count, GLES2Util::GetGLTypeSizeForTexturesAndBuffers(type), &size)) {
 208     return false;
 209   }
 210
 211   if (!SafeAddUint32(offset, size, &size)) {
 212     return false;
 213   }
 214
 215   if (size > static_cast<uint32>(size_)) {
 216     return false;
 217   }
 218
 219   if (!shadowed_) {
 220     return false;
 221   }
 222
 223   // Scan the range for the max value and store
 224   GLuint max_v = 0;
 225   switch (type) {
 226     case GL_UNSIGNED_BYTE:
 227       max_v = GetMaxValue<uint8>(shadow_.get(), offset, count);
 228       break;
 229     case GL_UNSIGNED_SHORT:
 230       // Check we are not accessing an odd byte for a 2 byte value.
 231       if ((offset & 1) != 0) {
 232         return false;
 233       }
 234       max_v = GetMaxValue<uint16>(shadow_.get(), offset, count);
 235       break;
 236     case GL_UNSIGNED_INT:
 237       // Check we are not accessing a non aligned address for a 4 byte value.
 238       if ((offset & 3) != 0) {
 239         return false;
 240       }
 241       max_v = GetMaxValue<uint32>(shadow_.get(), offset, count);
 242       break;
 243     default:
 244       NOTREACHED();  // should never get here by validation.
 245       break;
 246   }
 247   range_set_.insert(std::make_pair(range, max_v));
 248   *max_value = max_v;
 249   return true;
 250 }
 251
 252 bool BufferManager::GetClientId(GLuint service_id, GLuint* client_id) const {
 253   // This doesn't need to be fast. It's only used during slow queries.
 254   for (BufferMap::const_iterator it = buffers_.begin();
 255        it != buffers_.end(); ++it) {
 256     if (it->second->service_id() == service_id) {
 257       *client_id = it->first;
 258       return true;
 259     }
 260   }
 261   return false;
 262 }
 263
 264 bool BufferManager::IsUsageClientSideArray(GLenum usage) {
 265   return usage == GL_STREAM_DRAW && use_client_side_arrays_for_stream_buffers_;
 266 }
 267
 268 bool BufferManager::UseNonZeroSizeForClientSideArrayBuffer() {
 269   return feature_info_.get() &&
 270          feature_info_->workarounds()
 271              .use_non_zero_size_for_client_side_stream_buffers;
 272 }
 273
 274 void BufferManager::SetInfo(
 275     Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data) {
 276   DCHECK(buffer);
 277   memory_tracker_->TrackMemFree(buffer->size());
 278   const bool is_client_side_array = IsUsageClientSideArray(usage);
 279   const bool support_fixed_attribs =
 280     gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
 281   const bool shadow = buffer->target() == GL_ELEMENT_ARRAY_BUFFER ||
 282                       allow_buffers_on_multiple_targets_ ||
 283                       (allow_fixed_attribs_ && !support_fixed_attribs) ||
 284                       is_client_side_array;
 285   buffer->SetInfo(size, usage, shadow, data, is_client_side_array);
 286   memory_tracker_->TrackMemAlloc(buffer->size());
 287 }
 288
 289 void BufferManager::ValidateAndDoBufferData(
 290     ContextState* context_state, GLenum target, GLsizeiptr size,
 291     const GLvoid * data, GLenum usage) {
 292   ErrorState* error_state = context_state->GetErrorState();
 293   if (!feature_info_->validators()->buffer_target.IsValid(target)) {
 294     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
 295         error_state, "glBufferData", target, "target");
 296     return;
 297   }
 298   if (!feature_info_->validators()->buffer_usage.IsValid(usage)) {
 299     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
 300         error_state, "glBufferData", usage, "usage");
 301     return;
 302   }
 303   if (size < 0) {
 304     ERRORSTATE_SET_GL_ERROR(
 305         error_state, GL_INVALID_VALUE, "glBufferData", "size < 0");
 306     return;
 307   }
 308
 309   Buffer* buffer = GetBufferInfoForTarget(context_state, target);
 310   if (!buffer) {
 311     ERRORSTATE_SET_GL_ERROR(
 312         error_state, GL_INVALID_VALUE, "glBufferData", "unknown buffer");
 313     return;
 314   }
 315
 316   if (!memory_tracker_->EnsureGPUMemoryAvailable(size)) {
 317     ERRORSTATE_SET_GL_ERROR(
 318         error_state, GL_OUT_OF_MEMORY, "glBufferData", "out of memory");
 319     return;
 320   }
 321
 322   DoBufferData(error_state, buffer, size, usage, data);
 323 }
 324
 325
 326 void BufferManager::DoBufferData(
 327     ErrorState* error_state,
 328     Buffer* buffer,
 329     GLsizeiptr size,
 330     GLenum usage,
 331     const GLvoid* data) {
 332   // Clear the buffer to 0 if no initial data was passed in.
 333   scoped_ptr<int8[]> zero;
 334   if (!data) {
 335     zero.reset(new int8[size]);
 336     memset(zero.get(), 0, size);
 337     data = zero.get();
 338   }
 339
 340   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glBufferData");
 341   if (IsUsageClientSideArray(usage)) {
 342     GLsizei empty_size = UseNonZeroSizeForClientSideArrayBuffer() ? 1 : 0;
 343     glBufferData(buffer->target(), empty_size, NULL, usage);
 344   } else {
 345     glBufferData(buffer->target(), size, data, usage);
 346   }
 347   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glBufferData");
 348   if (error == GL_NO_ERROR) {
 349     SetInfo(buffer, size, usage, data);
 350   } else {
 351     SetInfo(buffer, 0, usage, NULL);
 352   }
 353 }
 354
 355 void BufferManager::ValidateAndDoBufferSubData(
 356   ContextState* context_state, GLenum target, GLintptr offset, GLsizeiptr size,
 357   const GLvoid * data) {
 358   ErrorState* error_state = context_state->GetErrorState();
 359   Buffer* buffer = GetBufferInfoForTarget(context_state, target);
 360   if (!buffer) {
 361     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, "glBufferSubData",
 362                             "unknown buffer");
 363     return;
 364   }
 365
 366   DoBufferSubData(error_state, buffer, offset, size, data);
 367 }
 368
 369 void BufferManager::DoBufferSubData(
 370     ErrorState* error_state,
 371     Buffer* buffer,
 372     GLintptr offset,
 373     GLsizeiptr size,
 374     const GLvoid* data) {
 375   if (!buffer->SetRange(offset, size, data)) {
 376     ERRORSTATE_SET_GL_ERROR(
 377         error_state, GL_INVALID_VALUE, "glBufferSubData", "out of range");
 378     return;
 379   }
 380
 381   if (!buffer->IsClientSideArray()) {
 382     glBufferSubData(buffer->target(), offset, size, data);
 383   }
 384 }
 385
 386 void BufferManager::ValidateAndDoGetBufferParameteriv(
 387     ContextState* context_state, GLenum target, GLenum pname, GLint* params) {
 388   Buffer* buffer = GetBufferInfoForTarget(context_state, target);
 389   if (!buffer) {
 390     ERRORSTATE_SET_GL_ERROR(
 391         context_state->GetErrorState(), GL_INVALID_OPERATION,
 392         "glGetBufferParameteriv", "no buffer bound for target");
 393     return;
 394   }
 395   switch (pname) {
 396     case GL_BUFFER_SIZE:
 397       *params = buffer->size();
 398       break;
 399     case GL_BUFFER_USAGE:
 400       *params = buffer->usage();
 401       break;
 402     default:
 403       NOTREACHED();
 404   }
 405 }
 406
 407 bool BufferManager::SetTarget(Buffer* buffer, GLenum target) {
 408   // Check that we are not trying to bind it to a different target.
 409   if (buffer->target() != 0 && buffer->target() != target &&
 410       !allow_buffers_on_multiple_targets_) {
 411     return false;
 412   }
 413   if (buffer->target() == 0) {
 414     buffer->set_target(target);
 415   }
 416   return true;
 417 }
 418
 419 // Since one BufferManager can be shared by multiple decoders, ContextState is
 420 // passed in each time and not just passed in during initialization.
 421 Buffer* BufferManager::GetBufferInfoForTarget(
 422     ContextState* state, GLenum target) const {
 423   switch (target) {
 424     case GL_ARRAY_BUFFER:
 425       return state->bound_array_buffer.get();
 426     case GL_ELEMENT_ARRAY_BUFFER:
 427       return state->vertex_attrib_manager->element_array_buffer();
 428     case GL_COPY_READ_BUFFER:
 429     case GL_COPY_WRITE_BUFFER:
 430     case GL_PIXEL_PACK_BUFFER:
 431     case GL_PIXEL_UNPACK_BUFFER:
 432     case GL_TRANSFORM_FEEDBACK_BUFFER:
 433     case GL_UNIFORM_BUFFER:
 434       NOTIMPLEMENTED();
 435       return nullptr;
 436     default:
 437       NOTREACHED();
 438       return nullptr;
 439   }
 440 }
 441
 442 }  // namespace gles2
 443 }  // namespace gpu
 444
 445