Plumbing explicit share groups through context creation

content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.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.
 
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "third_party/khronos/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
-#include "base/synchronization/lock.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/gles2_trace_implementation.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
@@ skipping 159 matching lines @@
   graphics_context_->OnErrorMessage(msg, id);
 }
 
 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits::SharedMemoryLimits()
     : command_buffer_size(kDefaultCommandBufferSize),
       start_transfer_buffer_size(kDefaultStartTransferBufferSize),
       min_transfer_buffer_size(kDefaultMinTransferBufferSize),
       max_transfer_buffer_size(kDefaultMaxTransferBufferSize),
       mapped_memory_reclaim_limit(gpu::gles2::GLES2Implementation::kNoLimit) {}
 
+WebGraphicsContext3DCommandBufferImpl::ShareGroup::ShareGroup() {
+}
+
+WebGraphicsContext3DCommandBufferImpl::ShareGroup::~ShareGroup() {
+  DCHECK(contexts_.empty());
+}
+
 WebGraphicsContext3DCommandBufferImpl::WebGraphicsContext3DCommandBufferImpl(
     int surface_id,
     const GURL& active_url,
     GpuChannelHost* host,
     const Attributes& attributes,
     bool bind_generates_resources,
-    const SharedMemoryLimits& limits)
+    const SharedMemoryLimits& limits,
+    WebGraphicsContext3DCommandBufferImpl* share_context)
     : initialize_failed_(false),
       visible_(false),
       host_(host),
       surface_id_(surface_id),
       active_url_(active_url),
       context_lost_callback_(0),
       context_lost_reason_(GL_NO_ERROR),
       error_message_callback_(0),
       attributes_(attributes),
       gpu_preference_(attributes.preferDiscreteGPU ? gfx::PreferDiscreteGpu
                                                    : gfx::PreferIntegratedGpu),
       weak_ptr_factory_(this),
       initialized_(false),
       gl_(NULL),
       bind_generates_resources_(bind_generates_resources),
       mem_limits_(limits),
       flush_id_(0) {
+  if (share_context) {
+    share_group_ = share_context->share_group_;
+  } else {
+    share_group_ = attributes_.shareResources ? NULL
+                                              : new ShareGroup();
+  }
 }
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
   if (real_gl_) {
     real_gl_->SetErrorMessageCallback(NULL);
   }
 
   Destroy();
 }
@@ skipping 49 matching lines @@
     attributes_.stencil = pvalues[2] > 0;
     attributes_.antialias = pvalues[3] > 0;
   }
 
   visible_ = true;
   initialized_ = true;
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::InitializeCommandBuffer(
-    bool onscreen) {
+    bool onscreen, WebGraphicsContext3DCommandBufferImpl* share_context) {
   if (!host_.get())
     return false;
+
+  CommandBufferProxyImpl* share_group_command_buffer = NULL;
+
+  if (share_context) {
+    share_group_command_buffer = share_context->command_buffer_.get();
+  }
+
   // We need to lock g_all_shared_contexts to ensure that the context we picked
   // for our share group isn't deleted.
   // (There's also a lock in our destructor.)
   base::AutoLock lock(g_all_shared_contexts_lock.Get());
-  CommandBufferProxyImpl* share_group = NULL;
-  if (attributes_.shareResources) {
+
+  if (attributes_.shareResources && !share_group_command_buffer) {
     ContextMap& all_contexts = g_all_shared_contexts.Get();
     ContextMap::const_iterator it = all_contexts.find(host_.get());
     if (it != all_contexts.end())
-      share_group = it->second->command_buffer_.get();
+      share_group_command_buffer = it->second->command_buffer_.get();
   }
 
   std::vector<int32> attribs;
   attribs.push_back(ALPHA_SIZE);
   attribs.push_back(attributes_.alpha ? 8 : 0);
   attribs.push_back(DEPTH_SIZE);
   attribs.push_back(attributes_.depth ? 24 : 0);
   attribs.push_back(STENCIL_SIZE);
   attribs.push_back(attributes_.stencil ? 8 : 0);
   attribs.push_back(SAMPLES);
   attribs.push_back(attributes_.antialias ? 4 : 0);
   attribs.push_back(SAMPLE_BUFFERS);
   attribs.push_back(attributes_.antialias ? 1 : 0);
   attribs.push_back(FAIL_IF_MAJOR_PERF_CAVEAT);
   attribs.push_back(attributes_.failIfMajorPerformanceCaveat ? 1 : 0);
   attribs.push_back(NONE);
 
   // Create a proxy to a command buffer in the GPU process.
   if (onscreen) {
     command_buffer_.reset(host_->CreateViewCommandBuffer(
         surface_id_,
-        share_group,
+        share_group_command_buffer,
         attribs,
         active_url_,
         gpu_preference_));
   } else {
     command_buffer_.reset(host_->CreateOffscreenCommandBuffer(
         gfx::Size(1, 1),
-        share_group,
+        share_group_command_buffer,
         attribs,
         active_url_,
         gpu_preference_));
   }
 
   if (!command_buffer_)
     return false;
 
   // Initialize the command buffer.
   return command_buffer_->Initialize();
 }
 
-bool WebGraphicsContext3DCommandBufferImpl::CreateContext(
-    bool onscreen) {
+bool WebGraphicsContext3DCommandBufferImpl::CreateContext(bool onscreen) {
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
-  if (!command_buffer_ &&
-      !InitializeCommandBuffer(onscreen)) {
-    return false;
+  scoped_refptr<gpu::gles2::ShareGroup> gles2_share_group;
+
+  if (!command_buffer_) {
+    scoped_ptr<base::AutoLock> share_group_lock;
+    WebGraphicsContext3DCommandBufferImpl* share_context = NULL;
+
+    if (share_group_) {
+      share_group_lock.reset(new base::AutoLock(share_group_->lock()));
+      share_context = share_group_->GetAnyContext();
+    }
+
+    if (!InitializeCommandBuffer(onscreen, share_context))
+      return false;
+
+    if (share_context)
+      gles2_share_group = share_context->GetImplementation()->share_group();
+
+    if (share_group_)
+      share_group_->AddContext(this);
   }

[piman, 2013/12/12 23:56:39]

So, there is a race risk here.
After you release the share_group_lock, the share_context could be deleted (on
another thread), and could be the last context in gles2_share_group.
If that's the case, on the service side, we will destroy the corresponding
ContextGroup, and free all remaining texture ids and friends.
However, because you keep the gles2::ShareGroup and will use it in the
GLES2Implementation, you get into the state where the ShareGroup doesn't match
the ContextGroup any more (it could have ids allocated on the client side that
don't exist on the service side), leading to problems later on.

I think you need to keep the lock held between when you grab the context and
both:
- you create the service-side context (InitializeCommandBuffer)
- you create the client-side context (GLES2Implementation).

At that point, the interaction between share_group_'s lock and the
g_all_shared_contexts_lock is starting to become complex.

At the same time, g_all_shared_contexts is really just like another ShareGroup.
Maybe we could combine both? Have a per-GpuChannelHost ShareGroup for
WebGraphicsContext3DCommandBufferImpl that have Attributes::shareResources set
and no explicit ShareGroup, and pick that in the constructor, making the rest of
the code common. WDYT?

[bajones, 2013/12/13 00:17:20]

I like it! I was thinking about replacing g_all_shared_contexts with a
ShareGroup, but hadn't considered attaching it to the GpuChannelHost, which
simplifies object lifetime management significantly.

Thanks for the suggestion!

 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!gles2_helper_->Initialize(mem_limits_.command_buffer_size))
     return false;
 
   if (attributes_.noAutomaticFlushes)
     gles2_helper_->SetAutomaticFlushes(false);
 
   // Create a transfer buffer used to copy resources between the renderer
   // process and the GPU process.
   transfer_buffer_ .reset(new gpu::TransferBuffer(gles2_helper_.get()));
 
   DCHECK(host_.get());
   scoped_ptr<base::AutoLock> lock;
-  scoped_refptr<gpu::gles2::ShareGroup> share_group;
-  if (attributes_.shareResources) {
+
+  if (attributes_.shareResources && !gles2_share_group) {
     // Make sure two clients don't try to create a new ShareGroup
     // simultaneously.
     lock.reset(new base::AutoLock(g_all_shared_contexts_lock.Get()));
     ContextMap& all_contexts = g_all_shared_contexts.Get();
     ContextMap::const_iterator it = all_contexts.find(host_.get());
     if (it != all_contexts.end()) {
-      share_group = it->second->GetImplementation()->share_group();
-      DCHECK(share_group);
+      gles2_share_group = it->second->GetImplementation()->share_group();
+      DCHECK(gles2_share_group);
     }
   }
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool free_command_buffer_when_invisible =
       command_line.HasSwitch(switches::kEnablePruneGpuCommandBuffers);
 
   // Create the object exposing the OpenGL API.
   real_gl_.reset(new gpu::gles2::GLES2Implementation(
       gles2_helper_.get(),
-      share_group,
+      gles2_share_group,
       transfer_buffer_.get(),
       bind_generates_resources_,
       free_command_buffer_when_invisible,
       command_buffer_.get()));
   gl_ = real_gl_.get();
 
   if (attributes_.shareResources) {
     // Don't add ourselves to the list before others can get to our ShareGroup.
     g_all_shared_contexts.Get().insert(std::make_pair(host_.get(), this));
     lock.reset();
@@ skipping 26 matching lines @@
   return true;
 }
 
 uint32_t WebGraphicsContext3DCommandBufferImpl::lastFlushID() {
   return flush_id_;
 }
 
 DELEGATE_TO_GL_R(insertSyncPoint, InsertSyncPointCHROMIUM, unsigned int)
 
 void WebGraphicsContext3DCommandBufferImpl::Destroy() {
+  if (share_group_) {
+    share_group_->RemoveContext(this);
+  }
+
   if (host_.get()) {
     base::AutoLock lock(g_all_shared_contexts_lock.Get());
     ContextMap& all_contexts = g_all_shared_contexts.Get();
     ContextMap::iterator it = std::find(
         all_contexts.begin(),
         all_contexts.end(),
         std::pair<GpuChannelHost* const,
                   WebGraphicsContext3DCommandBufferImpl*>(host_.get(), this));
     if (it != all_contexts.end())
       all_contexts.erase(it);
@@ skipping 732 matching lines @@
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   return state.error == gpu::error::kLostContext;
 }
 
 // static
 WebGraphicsContext3DCommandBufferImpl*
 WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
     GpuChannelHost* host,
     const WebGraphicsContext3D::Attributes& attributes,
     const GURL& active_url,
-    const SharedMemoryLimits& limits) {
+    const SharedMemoryLimits& limits,
+    WebGraphicsContext3D* share_context) {

[piman, 2013/12/12 23:56:39]

nit: pass a WebGraphicsContext3DCommandBufferImpl here, making it explicit to
the caller that it's responsible for ensuring the type correctness.

   if (!host)
     return NULL;
+
+  WebGraphicsContext3DCommandBufferImpl* share_context_impl = NULL;
+  if (share_context) {
+    share_context_impl =
+        static_cast<WebGraphicsContext3DCommandBufferImpl*>(share_context);
+  }
+
   return new WebGraphicsContext3DCommandBufferImpl(0,
                                                    active_url,
                                                    host,
                                                    attributes,
                                                    false,
-                                                   limits);
+                                                   limits,
+                                                   share_context_impl);
 }
 
 DELEGATE_TO_GL_5(texImageIOSurface2DCHROMIUM, TexImageIOSurface2DCHROMIUM,
                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Duint, WGC3Duint)
 
 DELEGATE_TO_GL_5(texStorage2DEXT, TexStorage2DEXT,
                  WGC3Denum, WGC3Dint, WGC3Duint, WGC3Dint, WGC3Dint)
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::createQueryEXT() {
   GLuint o;
@@ skipping 149 matching lines @@
       command_buffer_->GetLastState().context_lost_reason);
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 
   DCHECK(host_.get());
   {
     base::AutoLock lock(g_all_shared_contexts_lock.Get());
     g_all_shared_contexts.Get().erase(host_.get());
   }
+
+  if (share_group_)
+    share_group_->RemoveAllContexts();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::OnErrorMessage(
     const std::string& message, int id) {
   if (error_message_callback_) {
     blink::WebString str = blink::WebString::fromUTF8(message.c_str());
     error_message_callback_->onErrorMessage(str, id);
   }
 }
 
 }  // namespace content