Add OrderingBarrierCHROMIUM API.

content/common/gpu/client/gpu_channel_host.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/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 12 matching lines @@
 
 using base::AutoLock;
 using base::MessageLoopProxy;
 
 namespace content {
 
 GpuListenerInfo::GpuListenerInfo() {}
 
 GpuListenerInfo::~GpuListenerInfo() {}
 
+ProxyFlushInfo::ProxyFlushInfo()
+    : flush_pending(false), route_id(0), put_offset(0), flush_count(0) {
+}
+
+ProxyFlushInfo::~ProxyFlushInfo() {
+}
+
 // static
 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     const IPC::ChannelHandle& channel_handle,
     base::WaitableEvent* shutdown_event,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
   DCHECK(factory->IsMainThread());
   scoped_refptr<GpuChannelHost> host =
       new GpuChannelHost(factory, gpu_info, gpu_memory_buffer_manager);
@@ skipping 30 matching lines @@
   channel_->AddFilter(sync_filter_.get());
 
   channel_filter_ = new MessageFilter();
 
   // Install the filter last, because we intercept all leftover
   // messages.
   channel_->AddFilter(channel_filter_.get());
 }
 
 bool GpuChannelHost::Send(IPC::Message* msg) {
+  AutoLock lock(context_lock_);
+  InternalFlush();
+  return InternalSend(msg);

[piman, 2015/02/05 01:14:15]

The main thing is that some of the messages are synchronous, and keeping the
lock while sending those is unfortunate (e.g. if it's a
WaitForGetOffsetInRange/WaitForTokenInRange which can be arbitrary long).

I /think/ it's ok to release after the InternalFlush, but it's subtle. The
argument is that if there's 2 (or more) threads trying to send a message "at the
same time" (without mutual exclusion), then they don't have an ordering
dependency between them (because nothing currently would guarantee ordering).
The only potential dependencies are between any previous Flush and each of the
message. The first one of these messages gets to grab the lock, and ensures that
the Flush will happen before that message, but also before any other message
will go through.

[vmiura, 2015/02/05 01:20:48]

Makes sense.

I think doing InternalFlush on every Send may be overkill.  Certain IPCs must be
ordered relative to the pending Flush(), but I'm not sure which.

For one, would it be sufficient to run InternalFlush() when the Send is from the
same route_id as the pending Flush?

Then, are there only specific IPCs within the route that need strict ordering
with the Flush?

+}
+
+bool GpuChannelHost::InternalSend(IPC::Message* msg) {
   // Callee takes ownership of message, regardless of whether Send is
   // successful. See IPC::Sender.
   scoped_ptr<IPC::Message> message(msg);
   // The GPU process never sends synchronous IPCs so clear the unblock flag to
   // preserve order.
   message->set_unblock(false);
 
   // Currently we need to choose between two different mechanisms for sending.
   // On the main thread we use the regular channel Send() method, on another
   // thread we use SyncMessageFilter. We also have to be careful interpreting
@@ skipping 12 matching lines @@
   } else if (base::MessageLoop::current()) {
     bool result = sync_filter_->Send(message.release());
     if (!result)
       DVLOG(1) << "GpuChannelHost::Send failed: SyncMessageFilter::Send failed";
     return result;
   }
 
   return false;
 }
 
+void GpuChannelHost::Flush(int route_id,
+                           int32 put_offset,
+                           uint32 flush_count,
+                           const std::vector<ui::LatencyInfo>& latency_info,
+                           bool shallow_flush) {
+  AutoLock lock(context_lock_);
+  if (flush_info_.flush_pending && flush_info_.route_id != route_id)
+    InternalFlush();
+
+  flush_info_.flush_pending = true;
+  flush_info_.route_id = route_id;
+  flush_info_.put_offset = put_offset;
+  flush_info_.flush_count = flush_count;
+  flush_info_.latency_info.insert(flush_info_.latency_info.end(),
+                                  latency_info.begin(), latency_info.end());
+
+  if (!shallow_flush)
+    InternalFlush();
+}
+
+void GpuChannelHost::InternalFlush() {
+  if (flush_info_.flush_pending) {
+    InternalSend(new GpuCommandBufferMsg_AsyncFlush(
+        flush_info_.route_id, flush_info_.put_offset, flush_info_.flush_count,
+        flush_info_.latency_info));
+    flush_info_.latency_info.clear();
+    flush_info_.flush_pending = false;
+  }
+}
+
 CommandBufferProxyImpl* GpuChannelHost::CreateViewCommandBuffer(
     int32 surface_id,
     CommandBufferProxyImpl* share_group,
     const std::vector<int32>& attribs,
     const GURL& active_url,
     gfx::GpuPreference gpu_preference) {
   TRACE_EVENT1("gpu",
                "GpuChannelHost::CreateViewCommandBuffer",
                "surface_id",
                surface_id);
@@ skipping 97 matching lines @@
 void GpuChannelHost::DestroyCommandBuffer(
     CommandBufferProxyImpl* command_buffer) {
   TRACE_EVENT0("gpu", "GpuChannelHost::DestroyCommandBuffer");
 
   int route_id = command_buffer->GetRouteID();
   Send(new GpuChannelMsg_DestroyCommandBuffer(route_id));
   RemoveRoute(route_id);
 
   AutoLock lock(context_lock_);
   proxies_.erase(route_id);
+  if (flush_info_.flush_pending && flush_info_.route_id == route_id)
+    flush_info_.flush_pending = false;
+
   delete command_buffer;
 }
 
 void GpuChannelHost::DestroyChannel() {
   // channel_ must be destroyed on the main thread.
   if (channel_.get() && !factory_->IsMainThread())
     factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
   channel_.reset();
 }
 
@@ skipping 144 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content