cc: Partial tile update for one-copy raster.

cc/resources/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/resources/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/resources/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 TileTaskData& data)
       : 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) {}
+        tile_task_data_(data),
+        reusing_raster_resource_(true),
+        sequence_(0) {
+    raster_resource_ = resource_pool->TryAcquireOldResource(
+        data.resource->size(), resource_format, data.previous_tile_id);
+    if (!raster_resource_) {
+      raster_resource_ = resource_pool->AcquireResource(data.resource->size(),
+                                                        resource_format);
+      reusing_raster_resource_ = false;
+
+      previous_raster_resource_ =
+          // XXX Readable.
+          resource_pool->TryAcquireOldBusyResource(
+              data.resource->size(), resource_format, data.previous_tile_id);
+    }
+
+    lock_.reset(new ResourceProvider::ScopedWriteLockGpuMemoryBuffer(
+        resource_provider_, raster_resource_->id()));
+    if (previous_raster_resource_) {
+      previous_lock_.reset(new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
+          resource_provider_, previous_raster_resource_->id()));
+    }
+  }
 
   ~RasterBufferImpl() override {
-    // Release write lock in case a copy was never scheduled.
+    // Release write/read lock in case a copy was never scheduled.
     lock_.reset();
+    previous_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_)
-      resource_pool_->ReleaseResource(raster_resource_.Pass());
+    if (raster_resource_) {
+      resource_pool_->ReleaseResource(raster_resource_.Pass(),
+                                      tile_task_data_.new_tile_id);
+    }
+    if (previous_raster_resource_) {
+      resource_pool_->ReleaseResource(raster_resource_.Pass(),
+                                      tile_task_data_.previous_tile_id);
+    }
   }
 
   // Overridden from RasterBuffer:
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
                 float scale) override {
     sequence_ = worker_pool_->PlaybackAndScheduleCopyOnWorkerThread(
-        lock_.Pass(), raster_resource_.Pass(), resource_, raster_source, rect,
-        scale);
+        reusing_raster_resource_, lock_.Pass(), raster_resource_.Pass(),
+        previous_lock_.Pass(), previous_raster_resource_.Pass(),
+        tile_task_data_, raster_source, rect, scale);
   }
 
  private:
   OneCopyTileTaskWorkerPool* worker_pool_;
   ResourceProvider* resource_provider_;
   ResourcePool* resource_pool_;
-  const Resource* resource_;
+  TileTaskData tile_task_data_;
+  bool reusing_raster_resource_;
   scoped_ptr<ScopedResource> raster_resource_;
+  scoped_ptr<ScopedResource> previous_raster_resource_;
   scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_;
+  scoped_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer> previous_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;
 
 // 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<ScopedResource> src,
-    const Resource* dst)
-    : write_lock(write_lock.Pass()), src(src.Pass()), dst(dst) {
+    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer>
+        raster_resource_write_lock,
+    scoped_ptr<ScopedResource> raster_resource,
+    scoped_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer>
+        previous_raster_resource_read_lock,
+    scoped_ptr<ScopedResource> previous_raster_resource,
+    const TileTaskData& data)
+    : raster_resource_write_lock(raster_resource_write_lock.Pass()),
+      raster_resource(raster_resource.Pass()),
+      previous_raster_resource_read_lock(
+          previous_raster_resource_read_lock.Pass()),
+      previous_raster_resource(previous_raster_resource.Pass()),
+      tile_task_data(data) {
 }
 
 OneCopyTileTaskWorkerPool::CopyOperation::~CopyOperation() {
 }
 
 // static
 scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
@@ skipping 148 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());
+    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(),
-                           resource));
+                           resource_provider_->best_texture_format(), data));
 }
 
 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,
-    scoped_ptr<ScopedResource> src,
-    const Resource* dst,
+    bool reusing_raster_resource,
+    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer>
+        raster_resource_write_lock,
+    scoped_ptr<ScopedResource> raster_resource,
+    scoped_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer>
+        previous_raster_resource_read_lock,
+    scoped_ptr<ScopedResource> previous_raster_resource,
+    const TileTaskData& tile_task_data,
     const RasterSource* raster_source,
     const gfx::Rect& rect,
     float scale) {
+  DCHECK_IMPLIES(reusing_raster_resource, !previous_raster_resource_read_lock);
   base::AutoLock lock(lock_);
 
   int failed_attempts = 0;
   while ((scheduled_copy_operation_count_ + issued_copy_operation_count_) >=
          kMaxCopyOperations) {
     // Ignore limit when shutdown is set.
     if (shutdown_)
       break;
 
     ++failed_attempts;
@@ skipping 16 matching lines @@
 
   // Increment |scheduled_copy_operation_count_| before releasing |lock_|.
   ++scheduled_copy_operation_count_;
 
   // There may be more work available, so wake up another worker thread.
   copy_operation_count_cv_.Signal();
 
   {
     base::AutoUnlock unlock(lock_);
 
-    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);
+      void* raster_data = nullptr;
+      bool rv = gpu_memory_buffer->Map(&raster_data);
       DCHECK(rv);
       int stride;
       gpu_memory_buffer->GetStride(&stride);
-      TileTaskWorkerPool::PlaybackToMemory(data, src->format(), src->size(),
-                                           stride, raster_source, rect, scale);
+
+      // If the |raster_resource| is already from the previous version then
+      // there's nothing we need to copy. But otherwise we try copy from the
+      // |previous_raster_resource| to |raster_resource| to reuse raster work if
+      // possible.
+      bool do_partial_update = reusing_raster_resource;
+      if (previous_raster_resource) {
+        gfx::GpuMemoryBuffer* previous_gpu_memory_buffer =
+            previous_raster_resource_read_lock->GetGpuMemoryBuffer();
+        if (previous_gpu_memory_buffer) {
+          void* previous_data = nullptr;
+          bool prv = previous_gpu_memory_buffer->Map(&previous_data);
+          DCHECK(prv);
+          int previous_stride;
+          previous_gpu_memory_buffer->GetStride(&previous_stride);
+
+          if (previous_stride == stride) {
+            DCHECK(rect.size() == raster_resource->size());
+            DCHECK(raster_resource->size() == previous_raster_resource->size());
+            DCHECK(raster_resource->format() ==
+                   previous_raster_resource->format());
+            gfx::Rect copy_area = rect;
+            copy_area.Subtract(tile_task_data.raster_dirty_rect);
+            uint8_t* previous_row = static_cast<uint8_t*>(previous_data);
+            uint8_t* raster_row = static_cast<uint8_t*>(raster_data);
+            int bytes_per_pixel =
+                BitsPerPixel(previous_raster_resource->format()) / 8;
+            int row_offset = copy_area.x() * bytes_per_pixel;
+            int bytes_per_row = copy_area.width() * bytes_per_pixel;
+            int rows = copy_area.height();
+            for (int y = copy_area.y(); y < rows; ++y) {
+              memcpy(raster_row + row_offset, previous_row + row_offset,
+                     bytes_per_row);
+              raster_row += stride;
+              previous_row += previous_stride;
+            }
+            do_partial_update = true;
+          }
+          previous_gpu_memory_buffer->Unmap();
+        }
+      }
+
+      gfx::Rect playback_rect = rect;
+      if (do_partial_update)
+        playback_rect.Intersect(tile_task_data.raster_dirty_rect);
+      DCHECK(!playback_rect.IsEmpty())
+          << "Why are we rastering a tile that's not dirty?";
+      TileTaskWorkerPool::PlaybackToMemory(
+          raster_data, raster_resource->format(), raster_resource->size(),
+          stride, raster_source, rect, playback_rect, scale);
       gpu_memory_buffer->Unmap();
     }
   }
 
-  pending_copy_operations_.push_back(
-      make_scoped_ptr(new CopyOperation(write_lock.Pass(), src.Pass(), dst)));
+  pending_copy_operations_.push_back(make_scoped_ptr(new CopyOperation(
+      raster_resource_write_lock.Pass(), raster_resource.Pass(),
+      previous_raster_resource_read_lock.Pass(),
+      previous_raster_resource.Pass(), tile_task_data)));
 
   // Acquire a sequence number for this copy operation.
   CopySequenceNumber 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,
         base::Bind(&OneCopyTileTaskWorkerPool::AdvanceLastFlushedCopyTo,
@@ skipping 58 matching lines @@
     // operations from "pending" to "issued" state.
     DCHECK_GE(scheduled_copy_operation_count_, copy_operations.size());
     scheduled_copy_operation_count_ -= copy_operations.size();
     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->raster_resource_write_lock.reset();
 
     // Copy contents of source resource to destination resource.
-    resource_provider_->CopyResource(copy_operation->src->id(),
-                                     copy_operation->dst->id());
+    resource_provider_->CopyResource(
+        copy_operation->raster_resource->id(),
+        copy_operation->tile_task_data.resource->id());
 
     // Return source resource to pool where it can be reused once copy
     // operation has completed and resource is no longer busy.
-    resource_pool_->ReleaseResource(copy_operation->src.Pass());
+    resource_pool_->ReleaseResource(copy_operation->raster_resource.Pass(),
+                                    copy_operation->tile_task_data.new_tile_id);
+    if (copy_operation->previous_raster_resource) {
+      resource_pool_->ReleaseResource(
+          copy_operation->previous_raster_resource.Pass(),
+          copy_operation->tile_task_data.previous_tile_id);
+    }
   }
 }
 
 void OneCopyTileTaskWorkerPool::
     ScheduleCheckForCompletedCopyOperationsWithLockAcquired(
         bool wait_if_needed) {
   lock_.AssertAcquired();
 
   if (check_for_completed_copy_operations_pending_)
     return;
@@ skipping 68 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