cc: Partial tile update for one-copy raster.

cc/raster/one_copy_tile_task_worker_pool.cc

 // Copyright 2014 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 "cc/raster/one_copy_tile_task_worker_pool.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/debug/traced_value.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace cc {
 namespace {
 
 class RasterBufferImpl : public RasterBuffer {
  public:
   RasterBufferImpl(OneCopyTileTaskWorkerPool* worker_pool,
                    ResourceProvider* resource_provider,
                    ResourcePool* resource_pool,
                    ResourceFormat resource_format,
-                   const Resource* resource)
+                   const Resource* upload_resource,
+                   uint64_t new_content_id,
+                   uint64_t previous_content_id)
       : worker_pool_(worker_pool),
         resource_provider_(resource_provider),
         resource_pool_(resource_pool),
-        resource_(resource),
-        raster_resource_(
-            resource_pool->AcquireResource(resource->size(), resource_format)),
-        lock_(new ResourceProvider::ScopedWriteLockGpuMemoryBuffer(
-            resource_provider_,
-            raster_resource_->id())),
-        sequence_(0) {}
+        upload_resource_(upload_resource),
+        new_content_id_(new_content_id),
+        reusing_raster_resource_(true),
+        sequence_(0) {
+    if (worker_pool->have_persistent_gpu_memory_buffers() &&
+        previous_content_id) {
+      raster_resource_ = resource_pool->TryAcquireResourceWithContentId(
+          upload_resource->size(), resource_format, previous_content_id);
+    }
+    if (!raster_resource_) {
+      raster_resource_ = resource_pool->AcquireResource(upload_resource->size(),
+                                                        resource_format);
+      reusing_raster_resource_ = false;
+    }
+
+    lock_.reset(new ResourceProvider::ScopedWriteLockGpuMemoryBuffer(
+        resource_provider_, raster_resource_->id()));
+  }
 
   ~RasterBufferImpl() override {
+    bool did_playback = !lock_;

[reveman, 2015/05/28 05:07:24]

you can use |sequence_| to determine if raster_resource_ was updated

[danakj, 2015/05/28 18:54:46]

Done.

     // Release write lock in case a copy was never scheduled.
     lock_.reset();
 
     // Make sure any scheduled copy operations are issued before we release the
     // raster resource.
     if (sequence_)
       worker_pool_->AdvanceLastIssuedCopyTo(sequence_);
 
-    // Return raster resource to pool so it can be used by another RasterBuffer
+    // Return resources to pool so they can be used by another RasterBuffer
     // instance.
-    if (raster_resource_)

[reveman, 2015/05/28 05:07:24]

I guess the removal of this is just a leftover from my partial copy patch,
correct?

[danakj, 2015/05/28 18:54:46]

Yep

-      resource_pool_->ReleaseResource(raster_resource_.Pass());
+    uint64_t id(did_playback ? new_content_id_ : 0);
+    resource_pool_->ReleaseResource(raster_resource_.Pass(), id);
   }
 
   // Overridden from RasterBuffer:
   void Playback(const RasterSource* raster_source,
-                const gfx::Rect& rect,
+                const gfx::Rect& raster_full_rect,
+                const gfx::Rect& raster_dirty_rect,
                 float scale) override {
     sequence_ = worker_pool_->PlaybackAndScheduleCopyOnWorkerThread(
-        lock_.Pass(), raster_resource_.get(), resource_, raster_source, rect,
+        reusing_raster_resource_, lock_.Pass(), raster_resource_.get(),
+        upload_resource_, raster_source, raster_full_rect, raster_dirty_rect,
         scale);
   }
 
  private:
   OneCopyTileTaskWorkerPool* worker_pool_;
   ResourceProvider* resource_provider_;
   ResourcePool* resource_pool_;
-  const Resource* resource_;
+  const Resource* upload_resource_;
+  uint64_t new_content_id_;
+  bool reusing_raster_resource_;
   scoped_ptr<ScopedResource> raster_resource_;
   scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_;
   CopySequenceNumber sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
 };
 
 // Flush interval when performing copy operations.
 const int kCopyFlushPeriod = 4;
 
 // Number of in-flight copy operations to allow.
 const int kMaxCopyOperations = 32;
 
 // Minimum number of rows per copy operation. 4 or greater is required to
 // support compressed texture formats.
 const size_t kMinRowsPerCopyOperation = 4;
 
 // Delay been checking for copy operations to complete.
 const int kCheckForCompletedCopyOperationsTickRateMs = 1;
 
 // Number of failed attempts to allow before we perform a check that will
 // wait for copy operations to complete if needed.
 const int kFailedAttemptsBeforeWaitIfNeeded = 256;
 
 }  // namespace
 
 OneCopyTileTaskWorkerPool::CopyOperation::CopyOperation(
-    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
+    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> src_write_lock,
     const Resource* src,
     const Resource* dst,
     const gfx::Rect& rect)
-    : write_lock(write_lock.Pass()), src(src), dst(dst), rect(rect) {
+    : src_write_lock(src_write_lock.Pass()), src(src), dst(dst), rect(rect) {
 }
 
 OneCopyTileTaskWorkerPool::CopyOperation::~CopyOperation() {
 }
 
 // static
 scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     ResourcePool* resource_pool,
-    size_t max_bytes_per_copy_operation) {
+    size_t max_bytes_per_copy_operation,
+    bool have_persistent_gpu_memory_buffers) {
   return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
       task_runner, task_graph_runner, context_provider, resource_provider,
-      resource_pool, max_bytes_per_copy_operation));
+      resource_pool, max_bytes_per_copy_operation,
+      have_persistent_gpu_memory_buffers));
 }
 
 OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     ResourcePool* resource_pool,
-    size_t max_bytes_per_copy_operation)
+    size_t max_bytes_per_copy_operation,
+    bool have_persistent_gpu_memory_buffers)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner->GetNamespaceToken()),
       context_provider_(context_provider),
       resource_provider_(resource_provider),
       resource_pool_(resource_pool),
       max_bytes_per_copy_operation_(max_bytes_per_copy_operation),
+      have_persistent_gpu_memory_buffers_(have_persistent_gpu_memory_buffers),
       last_issued_copy_operation_(0),
       last_flushed_copy_operation_(0),
       lock_(),
       copy_operation_count_cv_(&lock_),
       issued_copy_operation_count_(0),
       next_copy_operation_sequence_(1),
       check_for_completed_copy_operations_pending_(false),
       shutdown_(false),
       weak_ptr_factory_(this),
       task_set_finished_weak_ptr_factory_(this) {
@@ skipping 118 matching lines @@
     task->RunReplyOnOriginThread();
   }
   completed_tasks_.clear();
 }
 
 ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat() {
   return resource_provider_->best_texture_format();
 }
 
 scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
-    const Resource* resource) {
-  DCHECK_EQ(resource->format(), resource_provider_->best_texture_format());
-  return make_scoped_ptr<RasterBuffer>(
-      new RasterBufferImpl(this, resource_provider_, resource_pool_,
-                           resource_provider_->best_texture_format(),
-                           resource));
+    const TileTaskData& data) {
+  DCHECK_EQ(data.resource->format(), resource_provider_->best_texture_format());
+  return make_scoped_ptr<RasterBuffer>(new RasterBufferImpl(
+      this, resource_provider_, resource_pool_,
+      resource_provider_->best_texture_format(), data.resource,
+      data.new_content_id, data.previous_content_id));
 }
 
 void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
     scoped_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 CopySequenceNumber
 OneCopyTileTaskWorkerPool::PlaybackAndScheduleCopyOnWorkerThread(
-    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
-    const Resource* src,
-    const Resource* dst,
+    bool reusing_raster_resource,
+    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer>
+        raster_resource_write_lock,
+    const Resource* raster_resource,
+    const Resource* upload_resource,
     const RasterSource* raster_source,
-    const gfx::Rect& rect,
+    const gfx::Rect& raster_full_rect,
+    const gfx::Rect& raster_dirty_rect,
     float scale) {
-  gfx::GpuMemoryBuffer* gpu_memory_buffer = write_lock->GetGpuMemoryBuffer();
+  gfx::GpuMemoryBuffer* gpu_memory_buffer =
+      raster_resource_write_lock->GetGpuMemoryBuffer();
   if (gpu_memory_buffer) {
     void* data = NULL;
     bool rv = gpu_memory_buffer->Map(&data);
     DCHECK(rv);
     int stride;
     gpu_memory_buffer->GetStride(&stride);
-    TileTaskWorkerPool::PlaybackToMemory(data, src->format(), src->size(),
-                                         stride, raster_source, rect, scale);
+
+    gfx::Rect playback_rect = raster_full_rect;
+    if (reusing_raster_resource) {
+      playback_rect.Intersect(raster_dirty_rect);
+    }
+    DCHECK(!playback_rect.IsEmpty())
+        << "Why are we rastering a tile that's not dirty?";
+    TileTaskWorkerPool::PlaybackToMemory(
+        data, raster_resource->format(), raster_resource->size(), stride,
+        raster_source, raster_full_rect, playback_rect, scale);
     gpu_memory_buffer->Unmap();
   }
 
   base::AutoLock lock(lock_);
 
   CopySequenceNumber sequence = 0;
-  size_t bytes_per_row =
-      (BitsPerPixel(src->format()) * src->size().width()) / 8;
+  size_t bytes_per_row = (BitsPerPixel(raster_resource->format()) *
+                          raster_resource->size().width()) /
+                         8;
   size_t chunk_size_in_rows = std::max(
       kMinRowsPerCopyOperation, max_bytes_per_copy_operation_ / bytes_per_row);
   size_t y = 0;
-  size_t height = src->size().height();
+  size_t height = raster_resource->size().height();
   while (y < height) {
     int failed_attempts = 0;
     while ((pending_copy_operations_.size() + issued_copy_operation_count_) >=
            kMaxCopyOperations) {
       // Ignore limit when shutdown is set.
       if (shutdown_)
         break;
 
       ++failed_attempts;
 
@@ skipping 14 matching lines @@
     }
 
     // There may be more work available, so wake up another worker thread.
     copy_operation_count_cv_.Signal();
 
     // Copy at most |chunk_size_in_rows|.
     size_t rows_to_copy = std::min(chunk_size_in_rows, height - y);
 
     // |write_lock| is passed to the first copy operation as it needs to be
     // released before we can issue a copy.
-    pending_copy_operations_.push_back(make_scoped_ptr(
-        new CopyOperation(write_lock.Pass(), src, dst,
-                          gfx::Rect(0, y, src->size().width(), rows_to_copy))));
-
+    pending_copy_operations_.push_back(make_scoped_ptr(new CopyOperation(
+        raster_resource_write_lock.Pass(), raster_resource, upload_resource,
+        gfx::Rect(0, y, raster_resource->size().width(), rows_to_copy))));

[reveman, 2015/05/28 05:07:24]

hard to see if this code was changed. looks like it's only renaming. would be
nice to avoid that unless it's important somehow?

[danakj, 2015/05/28 18:54:46]

this is just renaming, to make it clear what resource we're rastering vs
uploading to. They are still src/dst inside CopyOperation (it's a src->dst copy)
but over here we're rastering some resource and rastering to the "src" was super
unclear. This helped me get my head around what was going on in this class, so
I'd like to keep it?

[reveman, 2015/05/29 14:50:26]

OK, I see, just some renaming that makes sense independent of partial updates..

     y += rows_to_copy;
 
     // Acquire a sequence number for this copy operation.
     sequence = next_copy_operation_sequence_++;
 
     // Post task that will advance last flushed copy operation to |sequence|
     // if we have reached the flush period.
     if ((sequence % kCopyFlushPeriod) == 0) {
       task_runner_->PostTask(
           FROM_HERE,
@@ skipping 57 matching lines @@
 
     // Increment |issued_copy_operation_count_| to reflect the transition of
     // copy operations from "pending" to "issued" state.
     issued_copy_operation_count_ += copy_operations.size();
   }
 
   while (!copy_operations.empty()) {
     scoped_ptr<CopyOperation> copy_operation = copy_operations.take_front();
 
     // Remove the write lock.
-    copy_operation->write_lock.reset();
+    copy_operation->src_write_lock.reset();
 
     // Copy contents of source resource to destination resource.
     resource_provider_->CopyResource(copy_operation->src->id(),
                                      copy_operation->dst->id(),
                                      copy_operation->rect);
   }
 }
 
 void OneCopyTileTaskWorkerPool::
     ScheduleCheckForCompletedCopyOperationsWithLockAcquired(
@@ skipping 73 matching lines @@
                             resource_pool_->total_memory_usage_bytes());
   staging_state->SetInteger("pending_copy_count",
                             resource_pool_->total_resource_count() -
                                 resource_pool_->acquired_resource_count());
   staging_state->SetInteger("bytes_pending_copy",
                             resource_pool_->total_memory_usage_bytes() -
                                 resource_pool_->acquired_memory_usage_bytes());
 }
 
 }  // namespace cc