Implemented new fence syncs which replaces the old sync points.

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/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 
 namespace content {
 namespace {
 
 // Global atomic to generate unique transfer buffer IDs.
 base::StaticAtomicSequenceNumber g_next_transfer_buffer_id;
 
 }  // namespace
 
 GpuChannelHost::StreamFlushInfo::StreamFlushInfo()
-    : flush_pending(false),
+    : next_stream_flush_id(1),
+      flushed_stream_flush_id(0),
+      verified_stream_flush_id(0),
+      flush_pending(false),
       route_id(MSG_ROUTING_NONE),
       put_offset(0),
-      flush_count(0) {}
+      flush_count(0),
+      flush_id(0) {}
 
 GpuChannelHost::StreamFlushInfo::~StreamFlushInfo() {}
 
 // static
 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
     GpuChannelHostFactory* factory,
     int channel_id,
     const gpu::GPUInfo& gpu_info,
     const IPC::ChannelHandle& channel_handle,
     base::WaitableEvent* shutdown_event,
@@ skipping 68 matching lines @@
     bool result = channel_->Send(message.release());
     if (!result)
       DVLOG(1) << "GpuChannelHost::Send failed: Channel::Send failed";
     return result;
   }
 
   bool result = sync_filter_->Send(message.release());
   return result;
 }
 
-void GpuChannelHost::OrderingBarrier(
+uint32_t GpuChannelHost::OrderingBarrier(
     int32 route_id,
     int32 stream_id,
     int32 put_offset,
     uint32 flush_count,
     const std::vector<ui::LatencyInfo>& latency_info,
     bool put_offset_changed,
     bool do_flush) {
   AutoLock lock(context_lock_);
   StreamFlushInfo& flush_info = stream_flush_info_[stream_id];
   if (flush_info.flush_pending && flush_info.route_id != route_id)
-    InternalFlush(stream_id);
+    InternalFlush(&flush_info);
 
   if (put_offset_changed) {
+    const uint32_t flush_id = flush_info.next_stream_flush_id++;
     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.flush_id = flush_id;
     flush_info.latency_info.insert(flush_info.latency_info.end(),
                                    latency_info.begin(), latency_info.end());
 
     if (do_flush)
-      InternalFlush(stream_id);
+      InternalFlush(&flush_info);
+
+    return flush_id;
   }
+  return 0;
 }
 
-void GpuChannelHost::InternalFlush(int32 stream_id) {
+void GpuChannelHost::InternalFlush(StreamFlushInfo* flush_info) {
   context_lock_.AssertAcquired();
-  StreamFlushInfo& flush_info = stream_flush_info_[stream_id];
-  DCHECK(flush_info.flush_pending);
+  DCHECK(flush_info);
+  DCHECK(flush_info->flush_pending);
+  DCHECK_LT(flush_info->flushed_stream_flush_id, flush_info->flush_id);
   Send(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;
+      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;
+
+  flush_info->flushed_stream_flush_id = flush_info->flush_id;
 }
 
 scoped_ptr<CommandBufferProxyImpl> GpuChannelHost::CreateViewCommandBuffer(
     int32 surface_id,
     CommandBufferProxyImpl* share_group,
     int32 stream_id,
     GpuStreamPriority stream_priority,
     const std::vector<int32>& attribs,
     const GURL& active_url,
     gfx::GpuPreference gpu_preference) {
@@ skipping 108 matching lines @@
 void GpuChannelHost::DestroyCommandBuffer(
     CommandBufferProxyImpl* command_buffer) {
   TRACE_EVENT0("gpu", "GpuChannelHost::DestroyCommandBuffer");
 
   int32 route_id = command_buffer->route_id();
   int32 stream_id = command_buffer->stream_id();
   Send(new GpuChannelMsg_DestroyCommandBuffer(route_id));
   RemoveRoute(route_id);
 
   AutoLock lock(context_lock_);
-  if (stream_flush_info_[stream_id].route_id == route_id)
-    stream_flush_info_.erase(stream_id);
+  StreamFlushInfo& flush_info = stream_flush_info_[stream_id];
+  if (flush_info.flush_pending && flush_info.route_id == route_id)
+    flush_info.flush_pending = false;
 }
 
 void GpuChannelHost::DestroyChannel() {
   DCHECK(factory_->IsMainThread());
   AutoLock lock(context_lock_);
   channel_.reset();
 }
 
 void GpuChannelHost::AddRoute(
     int route_id, base::WeakPtr<IPC::Listener> listener) {
@@ skipping 72 matching lines @@
 }
 
 int32 GpuChannelHost::GenerateRouteID() {
   return next_route_id_.GetNext();
 }
 
 int32 GpuChannelHost::GenerateStreamID() {
   return next_stream_id_.GetNext();
 }
 
+uint32_t GpuChannelHost::ValidateFlushIDReachedServer(int32 stream_id) {
+  // Store what flush ids we will be validating for all streams.
+  base::hash_map<int32, uint32_t> validate_flushes;
+  uint32_t flushed_stream_flush_id = 0;
+  uint32_t verified_stream_flush_id = 0;
+  {
+    AutoLock lock(context_lock_);
+    for (const auto& iter : stream_flush_info_) {
+      const int32 iter_stream_id = iter.first;
+      const StreamFlushInfo& flush_info = iter.second;
+      if (iter_stream_id == stream_id) {
+        flushed_stream_flush_id = flush_info.flushed_stream_flush_id;
+        verified_stream_flush_id = flush_info.verified_stream_flush_id;
+      }
+
+      if (flush_info.flushed_stream_flush_id >
+          flush_info.verified_stream_flush_id) {
+        validate_flushes.insert(
+            std::make_pair(iter_stream_id, flush_info.flushed_stream_flush_id));
+      }
+    }
+  }
+
+  if (flushed_stream_flush_id == verified_stream_flush_id) {
+    // Current stream has no unverified flushes.
+    return verified_stream_flush_id;
+  }
+
+  if (Send(new GpuChannelMsg_Nop())) {
+    // Update verified flush id for all streams.
+    uint32_t highest_flush_id = 0;
+    AutoLock lock(context_lock_);
+    for (const auto& iter : validate_flushes) {
+      const int32 validated_stream_id = iter.first;
+      const uint32_t validated_flush_id = iter.second;
+      StreamFlushInfo& flush_info = stream_flush_info_[validated_stream_id];
+      if (flush_info.verified_stream_flush_id < validated_flush_id) {
+        flush_info.verified_stream_flush_id = validated_flush_id;
+      }
+
+      if (validated_stream_id == stream_id)
+        highest_flush_id = flush_info.verified_stream_flush_id;
+    }
+
+    return highest_flush_id;
+  }
+
+  return 0;
+}
+
+uint32_t GpuChannelHost::GetHighestValidatedFlushID(int32 stream_id) {
+  AutoLock lock(context_lock_);
+  StreamFlushInfo& flush_info = stream_flush_info_[stream_id];
+  return flush_info.verified_stream_flush_id;
+}
+
 GpuChannelHost::~GpuChannelHost() {
 #if DCHECK_IS_ON()
   AutoLock lock(context_lock_);
   DCHECK(!channel_)
       << "GpuChannelHost::DestroyChannel must be called before destruction.";
 #endif
 }
 
 GpuChannelHost::MessageFilter::ListenerInfo::ListenerInfo() {}
 
@@ skipping 58 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content