cc: Detect miss-behaving fence extensions when using 1-copy rasterizer.

cc/resources/one_copy_raster_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_raster_worker_pool.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
@@ skipping 69 matching lines @@
 
 // Flush interval when performing copy operations.
 const int kCopyFlushPeriod = 4;
 
 // Number of in-flight copy operations to allow.
 const int kMaxCopyOperations = 16;
 
 // 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;

[vmpstr, 2014/10/29 17:36:25]

Is there any way we can eliminate some of these constants going forward? Perhaps
expressing one in terms of the other in some cases? Wdyt?

[reveman, 2014/10/29 18:42:48]

Not sure. This last constant is just to detect driver bugs really. I'd like to
keep them separate for now in case I've set some of them a bit to aggressively
low so it's easy to adjust one without affecting another until we have a good
idea what good values are.

The important part is that we never expose these as settings or make them
different depending on the platform. That would be a failure.

+
 }  // namespace
 
 OneCopyRasterWorkerPool::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) {
 }
 
 OneCopyRasterWorkerPool::CopyOperation::~CopyOperation() {
@@ skipping 88 matching lines @@
   size_t task_count[kNumberOfTaskSets] = {0};
 
   for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
     new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
         task_runner_.get(),
         base::Bind(&OneCopyRasterWorkerPool::OnRasterFinished,
                    raster_finished_weak_ptr_factory_.GetWeakPtr(),
                    task_set));
   }
 
-  resource_pool_->CheckBusyResources();
+  resource_pool_->CheckBusyResources(false);
 
   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
        it != queue->items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
     RasterTask* task = item.task;
     DCHECK(!task->HasCompleted());
 
     for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
       if (!item.task_sets[task_set])
@@ skipping 67 matching lines @@
     const Resource* dst,
     const RasterSource* raster_source,
     const gfx::Rect& rect,
     float scale,
     RenderingStatsInstrumentation* stats) {
   CopySequenceNumber sequence;
 
   {
     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;
+
+      // Schedule a check that will also wait for operations to complete
+      // after too many failed attempts.
+      bool wait_if_needed = failed_attempts > kFailedAttemptsBeforeWaitIfNeeded;
+
       // Schedule a check for completed copy operations if too many operations
       // are currently in-flight.
-      ScheduleCheckForCompletedCopyOperationsWithLockAcquired();
+      ScheduleCheckForCompletedCopyOperationsWithLockAcquired(wait_if_needed);
 
       {
         TRACE_EVENT0("cc", "WaitingForCopyOperationsToComplete");
 
         // Wait for in-flight copy operations to drop below limit.
         copy_operation_count_cv_.Wait();
       }
     }
 
     // Increment |scheduled_copy_operation_count_| before releasing |lock_|.
@@ skipping 77 matching lines @@
 }
 
 void OneCopyRasterWorkerPool::IssueCopyOperations(int64 count) {
   TRACE_EVENT1(
       "cc", "OneCopyRasterWorkerPool::IssueCopyOperations", "count", count);
 
   CopyOperation::Deque copy_operations;
 
   // This is a good time to check for completed copy operations as
   // |issued_copy_operation_count_| need to be updated below.
-  resource_pool_->CheckBusyResources();
+  resource_pool_->CheckBusyResources(false);
 
   {
     base::AutoLock lock(lock_);
 
     for (int64 i = 0; i < count; ++i) {
       DCHECK(!pending_copy_operations_.empty());
       copy_operations.push_back(pending_copy_operations_.take_front());
     }
 
     // Decrement |scheduled_copy_operation_count_| and increment
@@ skipping 16 matching lines @@
     resource_provider_->CopyResource(copy_operation->src->id(),
                                      copy_operation->dst->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());
   }
 }
 
 void OneCopyRasterWorkerPool::
-    ScheduleCheckForCompletedCopyOperationsWithLockAcquired() {
+    ScheduleCheckForCompletedCopyOperationsWithLockAcquired(
+        bool wait_if_needed) {
   lock_.AssertAcquired();
 
   if (check_for_completed_copy_operations_pending_)
     return;
 
   base::TimeTicks now = base::TimeTicks::Now();
 
   // Schedule a check for completed copy operations as soon as possible but
   // don't allow two consecutive checks to be scheduled to run less than the
   // tick rate apart.
   base::TimeTicks next_check_for_completed_copy_operations_time =
       std::max(last_check_for_completed_copy_operations_time_ +
                    base::TimeDelta::FromMilliseconds(
                        kCheckForCompletedCopyOperationsTickRateMs),
                now);
 
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&OneCopyRasterWorkerPool::CheckForCompletedCopyOperations,
-                 weak_ptr_factory_.GetWeakPtr()),
+                 weak_ptr_factory_.GetWeakPtr(),
+                 wait_if_needed),
       next_check_for_completed_copy_operations_time - now);
 
   last_check_for_completed_copy_operations_time_ =
       next_check_for_completed_copy_operations_time;
   check_for_completed_copy_operations_pending_ = true;
 }
 
-void OneCopyRasterWorkerPool::CheckForCompletedCopyOperations() {
-  TRACE_EVENT0("cc",
-               "OneCopyRasterWorkerPool::CheckForCompletedCopyOperations");
+void OneCopyRasterWorkerPool::CheckForCompletedCopyOperations(
+    bool wait_if_needed) {
+  TRACE_EVENT1("cc",
+               "OneCopyRasterWorkerPool::CheckForCompletedCopyOperations",
+               "wait_if_needed",
+               wait_if_needed);
 
-  resource_pool_->CheckBusyResources();
+  resource_pool_->CheckBusyResources(wait_if_needed);
 
   {
     base::AutoLock lock(lock_);
 
     DCHECK(check_for_completed_copy_operations_pending_);
     check_for_completed_copy_operations_pending_ = false;
 
     // The number of busy resources in the pool reflects the number of issued
     // copy operations that have not yet completed.
     issued_copy_operation_count_ = resource_pool_->busy_resource_count();
@@ skipping 28 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