Free worker context resources on idle.

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 35 matching lines @@
 #include "base/command_line.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 // Class that DCHECKs if it is destructed without first having Release called.
-class ScopedVisibilityImpl : public ContextSupport::ScopedVisibility {
+template <typename T>
+class ScopedContextSupportToken : public T {
  public:
-  explicit ScopedVisibilityImpl(ContextSupport* context_support)
+  explicit ScopedContextSupportToken(ContextSupport* context_support)
       : initial_context_support_(context_support) {}
-  ~ScopedVisibilityImpl() { DCHECK(!initial_context_support_); }
+
+  ~ScopedContextSupportToken() { DCHECK(!initial_context_support_); }
 
   void Release(ContextSupport* context_support) {
     DCHECK_EQ(initial_context_support_, context_support);
     initial_context_support_ = nullptr;
   }
 
  private:
   const ContextSupport* initial_context_support_;
 };
 
+using ScopedVisibilityImpl =
+    ScopedContextSupportToken<ContextSupport::ScopedVisibility>;
+using ScopedBusyImpl = ScopedContextSupportToken<ContextSupport::ScopedBusy>;
+
 void CopyRectToBuffer(const void* pixels,
                       uint32_t height,
                       uint32_t unpadded_row_size,
                       uint32_t pixels_padded_row_size,
                       void* buffer,
                       uint32_t buffer_padded_row_size) {
   if (height == 0)
     return;
   const int8_t* source = static_cast<const int8_t*>(pixels);
   int8_t* dest = static_cast<int8_t*>(buffer);
@@ skipping 13 matching lines @@
 GLuint ToGLuint(const void* ptr) {
   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
 }
 
 static base::StaticAtomicSequenceNumber g_flush_id;
 
 uint32_t GenerateNextFlushId() {
   return static_cast<uint32_t>(g_flush_id.GetNext());
 }
 
+const base::TimeDelta kIdleCallbackDelay = base::TimeDelta::FromSeconds(1);
+
 }  // anonymous namespace
 
 #if !defined(_MSC_VER)
 const size_t GLES2Implementation::kMaxSizeOfSimpleResult;
 const unsigned int GLES2Implementation::kStartingOffset;
 #endif
 
 GLES2Implementation::GLStaticState::GLStaticState() {
 }
 
@@ skipping 60 matching lines @@
 #else
           // Do not use more than 5% of extra shared memory, and do not
           // use any extra for memory contrained devices (<=1GB).
           base::SysInfo::AmountOfPhysicalMemory() > 1024 * 1024 * 1024
               ? base::saturated_cast<uint32_t>(
                     base::SysInfo::AmountOfPhysicalMemory() / 20)
               : 0),
 #endif
       current_trace_stack_(0),
       gpu_control_(gpu_control),
+      task_runner_(std::move(task_runner)),
       capabilities_(gpu_control->GetCapabilities()),
       cached_extension_string_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(helper);
   DCHECK(transfer_buffer);
   DCHECK(gpu_control);
 
   std::stringstream ss;
   ss << std::hex << this;
   this_in_hex_ = ss.str();
@@ skipping 92 matching lines @@
         this, "GLES2Implementation", base::ThreadTaskRunnerHandle::Get());
   }
 
   return true;
 }
 
 GLES2Implementation::~GLES2Implementation() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
+  CancelIdleCallback();
+
   // Make sure the queries are finished otherwise we'll delete the
   // shared memory (mapped_memory_) which will free the memory used
   // by the queries. The GPU process when validating that memory is still
   // shared will fail and abort (ie, it will stop running).
   WaitForCmd();
   query_tracker_.reset();
 
   // GLES2Implementation::Initialize() could fail before allocating
   // reserved_ids_, so we need delete them carefully.
   if (support_client_side_arrays_ && reserved_ids_[0]) {
@@ skipping 5590 matching lines @@
   DCHECK(visibility);
   DCHECK_GT(num_visible_clients_, 0u);
   --num_visible_clients_;
   static_cast<ScopedVisibilityImpl*>(visibility.get())->Release(this);
 }
 
 bool GLES2Implementation::AnyClientsVisible() const {
   return num_visible_clients_ > 0;
 }
 
+std::unique_ptr<ContextSupport::ScopedBusy>
+GLES2Implementation::ClientBecameBusy() {
+  base::AutoLock hold(idle_lock_);
+  DCHECK(is_idle_);
+  is_idle_ = false;
+  // Increment the idle callback generation to cancel any pending callbacks.
+  ++current_idle_callback_generation_;
+
+  return base::MakeUnique<ScopedBusyImpl>(this);
+}
+
+void GLES2Implementation::ClientBecameNotBusy(
+    std::unique_ptr<ScopedBusy> busy) {
+  DCHECK(busy);
+
+  base::AutoLock hold(idle_lock_);
+  DCHECK(!is_idle_);
+  is_idle_ = true;
+
+  if (idle_callback_ && task_runner_) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&GLES2Implementation::RunIdleCallback,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              current_idle_callback_generation_),
+        kIdleCallbackDelay);
+  }
+
+  static_cast<ScopedBusyImpl*>(busy.get())->Release(this);
+}
+
+void GLES2Implementation::SetIdleCallback(const base::Closure& callback) {
+  base::AutoLock hold(idle_lock_);
+  idle_callback_ = callback;
+}
+
 void GLES2Implementation::SetLostContextCallback(
     const base::Closure& callback) {
   lost_context_callback_ = callback;
 }
 
 GLuint64 GLES2Implementation::InsertFenceSyncCHROMIUM() {
   const uint64_t release = gpu_control_->GenerateFenceSyncRelease();
   helper_->InsertFenceSyncCHROMIUM(release);
   return release;
 }
@@ skipping 1014 matching lines @@
     return;
   }
   GetStringHelper(GL_EXTENSIONS);
 }
 
 void GLES2Implementation::InvalidateCachedExtensions() {
   cached_extension_string_ = nullptr;
   cached_extensions_.clear();
 }
 
+void GLES2Implementation::RunIdleCallback(uint32_t callback_generation) const {
+  base::AutoLock hold(idle_lock_);
+
+  if (!idle_callback_)
+    return;
+  if (callback_generation != current_idle_callback_generation_)
+    return;
+
+  idle_callback_.Run();
+}
+
+void GLES2Implementation::CancelIdleCallback() {
+  base::AutoLock hold(idle_lock_);
+  ++current_idle_callback_generation_;
+}
+
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu