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 171 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 134 matching lines @@
     FlushDriverCachesCHROMIUM();
 
     // Flush will delete transfer buffer resources if
     // |aggressively_free_resources_| is true.
     Flush();
   } else {
     ShallowFlushCHROMIUM();
   }
 }
 
+void GLES2Implementation::TrimResources() {
+  TRACE_EVENT0("gpu", "GLES2Implementation::TrimResources");
+
+  bool initial_state = aggressively_free_resources_;
+
+  SetAggressivelyFreeResources(true);
+
+  if (!initial_state) {
+    SetAggressivelyFreeResources(false);
+  }
+}
+
 bool GLES2Implementation::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   if (!transfer_buffer_->HaveBuffer())
     return true;
 
   const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
 
@@ skipping 5429 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() {
+  DCHECK(is_idle_);
+  is_idle_ = false;
+
+  if (idle_callback_) {
+    // We can only modify |pending_idle_callback_| from the provided callback

[danakj, 2016/08/23 01:26:25]

Its kinda awk if you end up running the cancel right after the callback because
of posting order.

What if you used a generation id like "scheduled idle 5" and "cancelled idle 5"
now you don't run 5. but if scheduled idle != cancelled idle then you let the
posted cleanup run? or something like that?

[ericrk, 2016/08/24 18:32:21]

It's actually a little bit tricky to avoid races like this. The problem has to
do with safely accessing the state related to the callback. 

Assuming this is a locking context, at the point when we call
ClientBecameBusy/ClientBecameNotBusy, we are locked by the caller. However, at
the point when the delayed task is run, we are no longer locked. This means we
can't safely access any mutable state that might be in use by another thread.

There are two ways to work around this:
 1) Ensure that any mutable state which affects the callback is *only* modified
from a single thread. This is what we currently do - the callable callback is
the "mutable state", and it is only scheduled/canceled/run on the callback
thread.
 2) Take an additional lock before modifying any callback related mutable state.

As mentioned, the code I initially wrote uses option (1). We could move to a
callback generation id, but modification of this ID would have to happen with
the same restrictions, using either (1) or (2).

If we use a generation id with option (1), we still have the same race where a
cancel can happen right after the callback is run, as we have to post generation
updates to the callback thread.

If we use a generation id with option (2), we need a new lock which is held
around modifications of the generation id, and this is still a bit racy.

The only way I can think of to minimize this race without doing (1) or (2) is to
add an additional "ShouldRunIdleCallback(uint32_t idle_callback_id)" on
ContextSupport. The external callback code could then call this after acquiring
the context lock, and early out if it returns false. This would ensure that
generation id was only checked / modified while the context lock is held.
However, this is pretty roundabout and puts additional checking burden on the
callback.

WDYT?

+    // thread due to CancellableCallback constraints. Move to that thread.
+    idle_callback_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&GLES2Implementation::CancelIdleCallback,
+                              weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  return base::MakeUnique<ScopedBusyImpl>(this);
+}
+
+void GLES2Implementation::ClientBecameNotBusy(
+    std::unique_ptr<ScopedBusy> busy) {
+  DCHECK(busy);
+  DCHECK(!is_idle_);
+  is_idle_ = true;
+
+  if (idle_callback_) {
+    // We can only modify |pending_idle_callback_| from the provided callback
+    // thread due to CancellableCallback constraints. Move to that thread.
+    idle_callback_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&GLES2Implementation::ScheduleIdleCallback,
+                              weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  static_cast<ScopedBusyImpl*>(busy.get())->Release(this);
+}
+
+void GLES2Implementation::SetIdleCallback(
+    const base::Closure& callback,
+    scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner) {
+  idle_callback_ = callback;
+  idle_callback_task_runner_ = std::move(callback_task_runner);
+}
+
 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::ScheduleIdleCallback() {
+  if (!idle_callback_)
+    return;
+  if (!pending_idle_callback_)
+    pending_idle_callback_.reset(new base::CancelableClosure());
+
+  pending_idle_callback_->Reset(idle_callback_);
+  idle_callback_task_runner_->PostDelayedTask(
+      FROM_HERE, pending_idle_callback_->callback(), kIdleCallbackDelay);
+}
+
+void GLES2Implementation::CancelIdleCallback() {
+  if (pending_idle_callback_)
+    pending_idle_callback_->Cancel();
+}
+
 // 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