gpu: Remove async texture uploads.

gpu/command_buffer/client/gles2_implementation.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 85 matching lines @@
       current_program_(0),
       bound_array_buffer_(0),
       bound_copy_read_buffer_(0),
       bound_copy_write_buffer_(0),
       bound_pixel_pack_buffer_(0),
       bound_pixel_unpack_buffer_(0),
       bound_transform_feedback_buffer_(0),
       bound_uniform_buffer_(0),
       bound_pixel_pack_transfer_buffer_id_(0),
       bound_pixel_unpack_transfer_buffer_id_(0),
-      async_upload_token_(0),
-      async_upload_sync_(NULL),
-      async_upload_sync_shm_id_(0),
-      async_upload_sync_shm_offset_(0),
       error_bits_(0),
       debug_(false),
       lose_context_when_out_of_memory_(lose_context_when_out_of_memory),
       support_client_side_arrays_(support_client_side_arrays),
       use_count_(0),
       error_message_callback_(NULL),
       current_trace_stack_(0),
       gpu_control_(gpu_control),
       capabilities_(gpu_control->GetCapabilities()),
       aggressively_free_resources_(false),
@@ skipping 31 matching lines @@
   if (!transfer_buffer_->Initialize(
       starting_transfer_buffer_size,
       kStartingOffset,
       min_transfer_buffer_size,
       max_transfer_buffer_size,
       kAlignment,
       kSizeToFlush)) {
     return false;
   }
 
-  mapped_memory_.reset(
-      new MappedMemoryManager(
-          helper_,
-          base::Bind(&GLES2Implementation::PollAsyncUploads,
-                     // The mapped memory manager is owned by |this| here, and
-                     // since its destroyed before before we destroy ourselves
-                     // we don't need extra safety measures for this closure.
-                     base::Unretained(this)),
-          mapped_memory_limit));
+  mapped_memory_.reset(new MappedMemoryManager(helper_, mapped_memory_limit));
 
   unsigned chunk_size = 2 * 1024 * 1024;
   if (mapped_memory_limit != kNoLimit) {
     // Use smaller chunks if the client is very memory conscientious.
     chunk_size = std::min(mapped_memory_limit / 4, chunk_size);
   }
   mapped_memory_->set_chunk_size_multiple(chunk_size);
 
   GLStaticState::ShaderPrecisionMap* shader_precisions =
       &static_state_.shader_precisions;
@@ skipping 65 matching lines @@
 
   // Release remaining BufferRange mem; This is when a MapBufferRange() is
   // called but not the UnmapBuffer() pair.
   ClearMappedBufferRangeMap();
 
   // Release any per-context data in share group.
   share_group_->FreeContext(this);
 
   buffer_tracker_.reset();
 
-  FreeAllAsyncUploadBuffers();
-
-  if (async_upload_sync_) {
-    mapped_memory_->Free(async_upload_sync_);
-    async_upload_sync_ = NULL;
-  }
-
   // Make sure the commands make it the service.
   WaitForCmd();
 }
 
 GLES2CmdHelper* GLES2Implementation::helper() const {
   return helper_;
 }
 
 IdHandlerInterface* GLES2Implementation::GetIdHandler(int namespace_id) const {
   return share_group_->GetIdHandler(namespace_id);
@@ skipping 21 matching lines @@
 
 uint32 GLES2Implementation::GetResultShmOffset() {
   return transfer_buffer_->GetResultOffset();
 }
 
 void GLES2Implementation::FreeUnusedSharedMemory() {
   mapped_memory_->FreeUnused();
 }
 
 void GLES2Implementation::FreeEverything() {
-  FreeAllAsyncUploadBuffers();
   WaitForCmd();
   query_tracker_->Shrink();
   FreeUnusedSharedMemory();
   transfer_buffer_->Free();
   helper_->FreeRingBuffer();
 }
 
 void GLES2Implementation::RunIfContextNotLost(const base::Closure& callback) {
   if (!helper_->IsContextLost())
     callback.Run();
@@ skipping 1644 matching lines @@
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferSubData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << offset << ", " << size << ", "
       << static_cast<const void*>(data) << ")");
   BufferSubDataHelper(target, offset, size, data);
   CheckGLError();
 }
 
 void GLES2Implementation::RemoveTransferBuffer(BufferTracker::Buffer* buffer) {
   int32 token = buffer->last_usage_token();
-  uint32 async_token = buffer->last_async_upload_token();
 
-  if (async_token) {
-    if (HasAsyncUploadTokenPassed(async_token)) {
-      buffer_tracker_->Free(buffer);
-    } else {
-      detached_async_upload_memory_.push_back(
-          std::make_pair(buffer->address(), async_token));
-      buffer_tracker_->Unmanage(buffer);
-    }
-  } else if (token) {
+  if (token) {
     if (helper_->HasTokenPassed(token))
       buffer_tracker_->Free(buffer);
     else
       buffer_tracker_->FreePendingToken(buffer, token);
   } else {
       buffer_tracker_->Free(buffer);
   }
 
   buffer_tracker_->RemoveBuffer(buffer->id());
 }
@@ skipping 2916 matching lines @@
 
 void GLES2Implementation::BeginQueryEXT(GLenum target, GLuint id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] BeginQueryEXT("
                  << GLES2Util::GetStringQueryTarget(target)
                  << ", " << id << ")");
 
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
-    case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     case GL_GET_ERROR_QUERY_CHROMIUM:
       break;
     case GL_COMMANDS_COMPLETED_CHROMIUM:
       if (!capabilities_.sync_query) {
         SetGLError(
             GL_INVALID_OPERATION, "glBeginQueryEXT",
             "not enabled for commands completed queries");
         return;
       }
@@ skipping 381 matching lines @@
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapBufferCHROMIUM("
       << target << ", " << GLES2Util::GetStringEnum(access) << ")");
   switch (target)  {
     case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
       if (access != GL_READ_ONLY) {
         SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
         return NULL;
       }
       break;
-    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
-      if (access != GL_WRITE_ONLY) {
-        SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
-        return NULL;
-      }
-      break;
     default:
       SetGLError(
           GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target");
       return NULL;
   }
   GLuint buffer_id;
   GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id);
   if (!buffer_id) {
     return NULL;
   }
   BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
   if (!buffer) {
     SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "invalid buffer");
     return NULL;
   }
   if (buffer->mapped()) {
     SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "already mapped");
     return NULL;
   }
   // Here we wait for previous transfer operations to be finished.
-  // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work
-  // with this method of synchronization. Until this is fixed,
-  // MapBufferCHROMIUM will not block even if the transfer is not ready
-  // for these calls.
   if (buffer->last_usage_token()) {
     helper_->WaitForToken(buffer->last_usage_token());
     buffer->set_last_usage_token(0);
   }
   buffer->set_mapped(true);
 
   GPU_CLIENT_LOG("  returned " << buffer->address());
   CheckGLError();
   return buffer->address();
 }
@@ skipping 16 matching lines @@
   }
   if (!buffer->mapped()) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM", "not mapped");
     return false;
   }
   buffer->set_mapped(false);
   CheckGLError();
   return true;
 }
 
-bool GLES2Implementation::EnsureAsyncUploadSync() {
-  if (async_upload_sync_)
-    return true;
-
-  int32 shm_id;
-  unsigned int shm_offset;
-  void* mem = mapped_memory_->Alloc(sizeof(AsyncUploadSync),
-                                    &shm_id,
-                                    &shm_offset);
-  if (!mem)
-    return false;
-
-  async_upload_sync_shm_id_ = shm_id;
-  async_upload_sync_shm_offset_ = shm_offset;
-  async_upload_sync_ = static_cast<AsyncUploadSync*>(mem);
-  async_upload_sync_->Reset();
-
-  return true;
-}
-
-uint32 GLES2Implementation::NextAsyncUploadToken() {
-  async_upload_token_++;
-  if (async_upload_token_ == 0)
-    async_upload_token_++;
-  return async_upload_token_;
-}
-
-void GLES2Implementation::PollAsyncUploads() {
-  if (!async_upload_sync_)
-    return;
-
-  if (helper_->IsContextLost()) {
-    DetachedAsyncUploadMemoryList::iterator it =
-        detached_async_upload_memory_.begin();
-    while (it != detached_async_upload_memory_.end()) {
-      mapped_memory_->Free(it->first);
-      it = detached_async_upload_memory_.erase(it);
-    }
-    return;
-  }
-
-  DetachedAsyncUploadMemoryList::iterator it =
-      detached_async_upload_memory_.begin();
-  while (it != detached_async_upload_memory_.end()) {
-    if (HasAsyncUploadTokenPassed(it->second)) {
-      mapped_memory_->Free(it->first);
-      it = detached_async_upload_memory_.erase(it);
-    } else {
-      break;
-    }
-  }
-}
-
-void GLES2Implementation::FreeAllAsyncUploadBuffers() {
-  // Free all completed unmanaged async uploads buffers.
-  PollAsyncUploads();
-
-  // Synchronously free rest of the unmanaged async upload buffers.
-  if (!detached_async_upload_memory_.empty()) {
-    WaitAllAsyncTexImage2DCHROMIUMHelper();
-    WaitForCmd();
-    PollAsyncUploads();
-  }
-}
-
-void GLES2Implementation::AsyncTexImage2DCHROMIUM(
-    GLenum target, GLint level, GLenum internalformat, GLsizei width,
-    GLsizei height, GLint border, GLenum format, GLenum type,
-    const void* pixels) {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
-      << width << ", " << height << ", " << border << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
-  if (level < 0 || height < 0 || width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
-    return;
-  }
-  if (border != 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "border != 0");
-    return;
-  }
-  uint32 size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
-  if (!GLES2Util::ComputeImageDataSizes(
-          width, height, 1, format, type, unpack_alignment_, &size,
-          &unpadded_row_size, &padded_row_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "image size too large");
-    return;
-  }
-
-  // If there's no data/buffer just issue the AsyncTexImage2D
-  if (!pixels && !bound_pixel_unpack_transfer_buffer_id_) {
-    helper_->AsyncTexImage2DCHROMIUM(
-       target, level, internalformat, width, height, format, type,
-       0, 0, 0, 0, 0);
-    return;
-  }
-
-  if (!EnsureAsyncUploadSync()) {
-    SetGLError(GL_OUT_OF_MEMORY, "glTexImage2D", "out of memory");
-    return;
-  }
-
-  // Otherwise, async uploads require a transfer buffer to be bound.
-  // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
-  // the buffer before the transfer is finished. (Currently such
-  // synchronization has to be handled manually.)
-  GLuint offset = ToGLuint(pixels);
-  BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
-      bound_pixel_unpack_transfer_buffer_id_,
-      "glAsyncTexImage2DCHROMIUM", offset, size);
-  if (buffer && buffer->shm_id() != -1) {
-    uint32 async_token = NextAsyncUploadToken();
-    buffer->set_last_async_upload_token(async_token);
-    helper_->AsyncTexImage2DCHROMIUM(
-        target, level, internalformat, width, height, format, type,
-        buffer->shm_id(), buffer->shm_offset() + offset,
-        async_token,
-        async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
-  }
-}
-
-void GLES2Implementation::AsyncTexSubImage2DCHROMIUM(
-    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-    GLsizei height, GLenum format, GLenum type, const void* pixels) {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glAsyncTexSubImage2DCHROMIUM("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
-  if (level < 0 || height < 0 || width < 0) {
-    SetGLError(
-        GL_INVALID_VALUE, "glAsyncTexSubImage2DCHROMIUM", "dimension < 0");
-    return;
-  }
-
-  uint32 size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
-  if (!GLES2Util::ComputeImageDataSizes(
-        width, height, 1, format, type, unpack_alignment_, &size,
-        &unpadded_row_size, &padded_row_size)) {
-    SetGLError(
-        GL_INVALID_VALUE, "glAsyncTexSubImage2DCHROMIUM", "size to large");
-    return;
-  }
-
-  if (!EnsureAsyncUploadSync()) {
-    SetGLError(GL_OUT_OF_MEMORY, "glTexImage2D", "out of memory");
-    return;
-  }
-
-  // Async uploads require a transfer buffer to be bound.
-  // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
-  // the buffer before the transfer is finished. (Currently such
-  // synchronization has to be handled manually.)
-  GLuint offset = ToGLuint(pixels);
-  BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
-      bound_pixel_unpack_transfer_buffer_id_,
-      "glAsyncTexSubImage2DCHROMIUM", offset, size);
-  if (buffer && buffer->shm_id() != -1) {
-    uint32 async_token = NextAsyncUploadToken();
-    buffer->set_last_async_upload_token(async_token);
-    helper_->AsyncTexSubImage2DCHROMIUM(
-        target, level, xoffset, yoffset, width, height, format, type,
-        buffer->shm_id(), buffer->shm_offset() + offset,
-        async_token,
-        async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
-  }
-}
-
-void GLES2Implementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glWaitAsyncTexImage2DCHROMIUM("
-      << GLES2Util::GetStringTextureTarget(target) << ")");
-  helper_->WaitAsyncTexImage2DCHROMIUM(target);
-  CheckGLError();
-}
-
-void GLES2Implementation::WaitAllAsyncTexImage2DCHROMIUMHelper() {
-  helper_->WaitAllAsyncTexImage2DCHROMIUM();
-}
-
-void GLES2Implementation::WaitAllAsyncTexImage2DCHROMIUM() {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix()
-      << "] glWaitAllAsyncTexImage2DCHROMIUM()");
-  WaitAllAsyncTexImage2DCHROMIUMHelper();
-  CheckGLError();
-}
-
 GLuint GLES2Implementation::InsertSyncPointCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertSyncPointCHROMIUM");
   helper_->CommandBufferHelper::Flush();
   return gpu_control_->InsertSyncPoint();
 }
 
 GLuint GLES2Implementation::InsertFutureSyncPointCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertFutureSyncPointCHROMIUM");
@@ skipping 527 matching lines @@
   CheckGLError();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu