cc: Partial tile update for one-copy raster.

cc/resources/one_copy_tile_task_worker_pool.cc

Index: cc/resources/one_copy_tile_task_worker_pool.cc
diff --git a/cc/resources/one_copy_tile_task_worker_pool.cc b/cc/resources/one_copy_tile_task_worker_pool.cc
index 23f372c15e2b13add87aacaa046b6a62528ac335..379e2dd5e5fc9b59ed7bbbc2ede738a520e4913d 100644
--- a/cc/resources/one_copy_tile_task_worker_pool.cc
+++ b/cc/resources/one_copy_tile_task_worker_pool.cc
@@ -26,31 +26,55 @@ class RasterBufferImpl : public RasterBuffer {
                    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_frame_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_frame_raster_resource_) {
+      previous_frame_lock_.reset(

[reveman, 2015/05/14 23:52:20]

We need to somehow explicitly allocated a GpuMemoryBuffer that provides the
reuse guarantees that this requires. I think the best would be to just implement
our own shared memory backed GpuMemoryBuffer here. It would only work in the
browser process where we can allocated shared memory but I assume that's fine
for now.

[danakj, 2015/05/15 00:09:58]

What's the plan to extend it to the renderer then? Can we just expose a promise
on the GpuMemoryBuffer API and only use this when that is true?

[reveman, 2015/05/15 00:33:20]

I'd like to have more data on performance and usage of different types of
buffers before we allow this in the general case. It might be easy to support in
a number of implementations but I'm not sure it's a good idea. It could result
in shadow copies of the data that make native buffers worse and have less
predictable performance than using shared memory.

+          new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
+              resource_provider_, previous_frame_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_frame_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_frame_raster_resource_) {
+      resource_pool_->ReleaseResource(raster_resource_.Pass(),
+                                      tile_task_data_.previous_tile_id);
+    }
   }
 
   // Overridden from RasterBuffer:
@@ -58,17 +82,22 @@ class RasterBufferImpl : public RasterBuffer {
                 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_frame_lock_.Pass(), previous_frame_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_frame_raster_resource_;

[reveman, 2015/05/14 23:52:20]

nit: previous_raster_resource_ instead as I think we should avoid the use of
"frame" here. this code is not aware of the concept of frames

[danakj, 2015/05/15 00:09:58]

Done.

   scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_;
+  scoped_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer>
+      previous_frame_lock_;

[reveman, 2015/05/14 23:52:20]

nit: previous_lock_

[danakj, 2015/05/15 00:09:58]

Done.

   CopySequenceNumber sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
@@ -92,8 +121,15 @@ const int kFailedAttemptsBeforeWaitIfNeeded = 256;
 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::ScopedReadLockGpuMemoryBuffer>
+        previous_frame_read_lock,
+    scoped_ptr<ScopedResource> previous_frame_src,
+    const TileTaskData& data)
+    : write_lock(write_lock.Pass()),
+      src(src.Pass()),
+      previous_frame_read_lock(previous_frame_read_lock.Pass()),
+      previous_frame_src(previous_frame_src.Pass()),
+      tile_task_data(data) {
 }
 
 OneCopyTileTaskWorkerPool::CopyOperation::~CopyOperation() {
@@ -262,12 +298,11 @@ ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat() {
 }
 
 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(
@@ -277,12 +312,17 @@ void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
 
 CopySequenceNumber
 OneCopyTileTaskWorkerPool::PlaybackAndScheduleCopyOnWorkerThread(
+    bool reusing_raster_resource,
     scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
     scoped_ptr<ScopedResource> src,
-    const Resource* dst,
+    scoped_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer>
+        previous_frame_read_lock,
+    scoped_ptr<ScopedResource> previous_frame_src,
+    const TileTaskData& tile_task_data,
     const RasterSource* raster_source,
     const gfx::Rect& rect,
     float scale) {
+  DCHECK_IMPLIES(reusing_raster_resource, !previous_frame_read_lock);
   base::AutoLock lock(lock_);
 
   int failed_attempts = 0;
@@ -326,14 +366,45 @@ OneCopyTileTaskWorkerPool::PlaybackAndScheduleCopyOnWorkerThread(
       DCHECK(rv);
       int stride;
       gpu_memory_buffer->GetStride(&stride);
+
+      // If the |src| is already from the previous frame then there's nothing
+      // we need to copy. But otherwise we try copy from the previous_frame_src
+      // to |src| to reuse raster work if possible.
+      bool do_partial_update = reusing_raster_resource;
+      if (previous_frame_src) {
+        gfx::GpuMemoryBuffer* previous_gpu_memory_buffer =
+            previous_frame_read_lock->GetGpuMemoryBuffer();
+        if (previous_gpu_memory_buffer) {
+          void* previous_data = NULL;
+          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) {

[reveman, 2015/05/14 23:52:20]

what if this is false?

[danakj, 2015/05/14 23:56:34]

We just don't use the old resource, and we re-raster.

+            size_t bytes = static_cast<size_t>(stride) * src->size().height();

[reveman, 2015/05/14 23:52:20]

Two problems here:

1. gfx::GpuMemoryBuffer::GetStride() can return a negative stride.

2. It's bad idea in general to assume that stride is similar to "width * bpp".
(e.g. an implementation can use a large buffer to store a number of smaller
buffers, a texture atlas basically). If we copy stride amount of bytes, then we
might be copying much more than needed and also writing to memory that is used
by the GPU.

I guess we could make these assumptions here if we knew how the GpuMemoryBuffer
was allocated and that is after all a requirement for being able to assume that
a previous buffer can be reused. I would still recommend fixing these two
problems in case we want to extend the use to non-shmem buffers in the future.

[danakj, 2015/05/14 23:56:34]

What does a negative stride mean?
https://code.google.com/p/chromium/codesearch#chromium/src/ui/gfx/gpu_memory_...
makes no mention of this.
Oh ok, I'll do a memcpy per row then.

[reveman, 2015/05/15 00:15:48]

No special meaning. If stride=-10 then start of row 4 for example is simply
located at -30 byte offset from start of row 1. It allows an implementation to
return buffers with a flipped Y axis. 

[danakj, 2015/05/15 00:40:09]

Ah okay, thanks. Fixed it.

+            memcpy(data, previous_data, bytes);
+            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(data, src->format(), src->size(),
-                                           stride, raster_source, rect, scale);
+                                           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(
+      write_lock.Pass(), src.Pass(), previous_frame_read_lock.Pass(),
+      previous_frame_src.Pass(), tile_task_data)));
 
   // Acquire a sequence number for this copy operation.
   CopySequenceNumber sequence = next_copy_operation_sequence_++;
@@ -415,12 +486,19 @@ void OneCopyTileTaskWorkerPool::IssueCopyOperations(int64 count) {
     copy_operation->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->src->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->src.Pass(),
+                                    copy_operation->tile_task_data.new_tile_id);
+    if (copy_operation->previous_frame_src) {
+      resource_pool_->ReleaseResource(
+          copy_operation->previous_frame_src.Pass(),
+          copy_operation->tile_task_data.previous_tile_id);
+    }
   }
 }