Perform glReadPixels with PBOs in the gpu, if PBOs are available.

gpu/command_buffer/service/query_manager.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.
 
 #include "gpu/command_buffer/service/query_manager.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/shared_memory.h"
@@ skipping 177 matching lines @@
     DCHECK(mem_params.shared_memory->memory());
     void *data = static_cast<int8*>(mem_params.shared_memory->memory()) +
         mem_params.shm_data_offset;
     QuerySync* sync = static_cast<QuerySync*>(data);
 
     // Need a MemoryBarrier here to ensure that upload completed before
     // submit_count was written to sync->process_count.
     base::subtle::MemoryBarrier();
     sync->process_count = submit_count;
   }
+  void MarkAsCompletedStage1(
+      uint32 submit_count, const AsyncMemoryParams& mem_params);
 };
 
 AsyncPixelTransfersCompletedQuery::AsyncPixelTransfersCompletedQuery(
     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool AsyncPixelTransfersCompletedQuery::Begin() {
   return true;
 }
 
 bool AsyncPixelTransfersCompletedQuery::End(uint32 submit_count) {
   AsyncMemoryParams mem_params;
   // Get the real shared memory since it might need to be duped to prevent
   // use-after-free of the memory.
   Buffer buffer = manager()->decoder()->GetSharedMemoryBuffer(shm_id());
   if (!buffer.shared_memory)
     return false;
   mem_params.shared_memory = buffer.shared_memory;
   mem_params.shm_size = buffer.size;
   mem_params.shm_data_offset = shm_offset();
   mem_params.shm_data_size = sizeof(QuerySync);
 
+  manager()->decoder()->WaitForReadPixels(
+      base::Bind(&AsyncPixelTransfersCompletedQuery::MarkAsCompletedStage1,
+                 this, submit_count, mem_params));

[piman, 2013/06/17 19:55:06]

The problem here is that for async texture upload, you will delay completion
significantly. For correctness on those, we only need to guarantee that the
command has been submitted to GL, not that it has completed on the GPU. It'll
add possibly a frame of latency to uploads, which means we may have more
checkerboarding or more jank when we wait on the completion to produce a frame.

You may want to separate the completion query for readpixels, or keep track here
if you're waiting on any readpixels or not.

[hubbe, 2013/06/25 20:02:51]

I changed this so that WaitForReadPixels doesn't automatically create a new
fence and callbacks are called immediately if no readpixels is actually pending
right now.

[piman, 2013/06/26 22:17:08]

So as I read it, and please explain to me if I missed something,
WaitForReadPixels will attach to the last fence inserted, whether it's within
the query or not. So in the case where you do an async readpixels followed by an
async upload, you'll still be waiting on the readpixels to be done and the fence
to be passed before returning the query for the async upload.

[hubbe, 2013/06/28 22:17:49]

Fixed by implementing a new query type.

+
+  return AddToPendingTransferQueue(submit_count);
+}
+
+void AsyncPixelTransfersCompletedQuery::MarkAsCompletedStage1(
+    uint32 submit_count,
+    const AsyncMemoryParams& mem_params) {
+
   // Ask AsyncPixelTransferDelegate to run completion callback after all
   // previous async transfers are done. No guarantee that callback is run
   // on the current thread.
   manager()->decoder()->GetAsyncPixelTransferManager()->AsyncNotifyCompletion(
       mem_params,
       base::Bind(AsyncPixelTransfersCompletedQuery::MarkAsCompletedThreadSafe,
                  submit_count));
 
-  return AddToPendingTransferQueue(submit_count);
+
 }
 
 bool AsyncPixelTransfersCompletedQuery::Process() {
   QuerySync* sync = manager()->decoder()->GetSharedMemoryAs<QuerySync*>(
       shm_id(), shm_offset(), sizeof(*sync));
   if (!sync)
     return false;
 
   // Check if completion callback has been run. sync->process_count atomicity
   // is guaranteed as this is already used to notify client of a completed
@@ skipping 185 matching lines @@
       target_(target),
       shm_id_(shm_id),
       shm_offset_(shm_offset),
       submit_count_(0),
       pending_(false),
       deleted_(false) {
   DCHECK(manager);
   manager_->StartTracking(this);
 }
 
+void QueryManager::Query::RunCallbacks() {
+  for (size_t i = 0; i < callbacks_.size(); i++) {
+    callbacks_[i].Run();
+  }
+  callbacks_.clear();
+}
+
+void QueryManager::Query::AddCallback(base::Closure callback) {
+  callbacks_.push_back(callback);

[piman, 2013/06/17 19:55:06]

This should call the callback if the query is not pending any more.

[hubbe, 2013/06/25 20:02:51]

Done. (In other CL)

+}
+
 QueryManager::Query::~Query() {
+  // Seems like this channel is shutting down with some callbacks

[piman, 2013/06/17 19:55:06]

note: this could also happen if the query is destroyed explicitly.
I think it's still good to call the callback either way. It could be useful to
send a bool with the callback on whether the query has completed, or whether it
was destroyed - though arguably the client-side can know.

[hubbe, 2013/06/25 20:02:51]

Handled in other CL.

+  // still active. Call the queries now to avoid leaks.
+  RunCallbacks();
   if (manager_) {
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 bool QueryManager::Query::MarkAsCompleted(uint64 result) {
   DCHECK(pending_);
   QuerySync* sync = manager_->decoder_->GetSharedMemoryAs<QuerySync*>(
       shm_id_, shm_offset_, sizeof(*sync));
@@ skipping 13 matching lines @@
 
 bool QueryManager::ProcessPendingQueries() {
   while (!pending_queries_.empty()) {
     Query* query = pending_queries_.front().get();
     if (!query->Process()) {
       return false;
     }
     if (query->pending()) {
       break;
     }
+    query->RunCallbacks();
     pending_queries_.pop_front();
   }
 
   return true;
 }
 
 bool QueryManager::HavePendingQueries() {
   return !pending_queries_.empty();
 }
 
 bool QueryManager::ProcessPendingTransferQueries() {
   while (!pending_transfer_queries_.empty()) {
     Query* query = pending_transfer_queries_.front().get();
     if (!query->Process()) {
       return false;
     }
     if (query->pending()) {
       break;
     }
+    query->RunCallbacks();
     pending_transfer_queries_.pop_front();
   }
 
   return true;
 }
 
 bool QueryManager::HavePendingTransferQueries() {
   return !pending_transfer_queries_.empty();
 }
 
@@ skipping 57 matching lines @@
 bool QueryManager::EndQuery(Query* query, uint32 submit_count) {
   DCHECK(query);
   if (!RemovePendingQuery(query)) {
     return false;
   }
   return query->End(submit_count);
 }
 
 }  // namespace gles2
 }  // namespace gpu
-
-