GPU Channel's now maintain a global order number for each processed IPC.

content/common/gpu/gpu_channel.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 
 #include <deque>
 #include <string>
 
+#include "base/atomicops.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
+#include "base/synchronization/lock.h"
+#include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_result_codes.h"
 #include "content/common/message_router.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 62 matching lines @@
   virtual base::ProcessId GetClientPID() const;
 
   int client_id() const { return client_id_; }
 
   uint64_t client_tracing_id() const { return client_tracing_id_; }
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() const {
     return io_task_runner_;
   }
 
+  // Thread-safe channel message functions.
+  bool HasQueuedMessages();
+  base::TimeTicks GetNextMessageTimeTick();
+  void PushBackMessage(uint32_t order_number, const IPC::Message& message);
+  void PushFrontMessage(const IPC::Message& message);
+
+  // TODO(dyen): Temporary sync point insertion hook.
+  void PushSyncPointMessage(uint32_t order_number, const IPC::Message& message,
+                            bool retire_sync_point, uint32_t sync_point_num);
+
+  // Process channel message from main thread.
+  void ProcessMessage(uint32_t order_number, const IPC::Message& message);
+
   // IPC::Listener implementation:
   bool OnMessageReceived(const IPC::Message& msg) override;
   void OnChannelError() override;
 
   // IPC::Sender implementation:
   bool Send(IPC::Message* msg) override;
 
   // Requeue the message that is currently being processed to the beginning of
   // the queue. Used when the processing of a message gets aborted because of
   // unscheduling conditions.
@@ skipping 30 matching lines @@
   // Called to add a listener for a particular message routing ID.
   // Returns true if succeeded.
   bool AddRoute(int32 route_id, IPC::Listener* listener);
 
   // Called to remove a listener for a particular message routing ID.
   void RemoveRoute(int32 route_id);
 
   gpu::PreemptionFlag* GetPreemptionFlag();
 
   bool handle_messages_scheduled() const { return handle_messages_scheduled_; }
-  uint64 messages_processed() const { return messages_processed_; }
 
   // If |preemption_flag->IsSet()|, any stub on this channel
   // should stop issuing GL commands. Setting this to NULL stops deferral.
   void SetPreemptByFlag(
       scoped_refptr<gpu::PreemptionFlag> preemption_flag);
 
   void CacheShader(const std::string& key, const std::string& shader);
 
   virtual void AddFilter(IPC::MessageFilter* filter);
   virtual void RemoveFilter(IPC::MessageFilter* filter);
 
   uint64 GetMemoryUsage();
 
   scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
       uint32 internalformat);
 
   bool allow_future_sync_points() const { return allow_future_sync_points_; }
 
   void HandleUpdateValueState(unsigned int target,
                               const gpu::ValueState& state);
 
   // Visible for testing.
   const gpu::ValueStateMap* pending_valuebuffer_state() const {
     return pending_valuebuffer_state_.get();
   }
 
+  uint32_t GetCurrentOrderNum() const { return current_order_num_; }
+  uint32_t GetProcessedOrderNum() const { return processed_order_num_; }
+  uint32_t GetUnprocessedOrderNum() const {
+    return base::subtle::Acquire_Load(&unprocessed_order_num_);
+  }
+
  protected:
   // The message filter on the io thread.
   scoped_refptr<GpuChannelMessageFilter> filter_;
 
   // Map of routing id to command buffer stub.
   base::ScopedPtrHashMap<int32, scoped_ptr<GpuCommandBufferStub>> stubs_;
 
  private:
   friend class GpuChannelMessageFilter;
 
   void OnDestroy();
 
   bool OnControlMessageReceived(const IPC::Message& msg);
 
   void HandleMessage();
 
   // Message handlers.
   void OnCreateOffscreenCommandBuffer(
       const gfx::Size& size,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id,
       bool* succeeded);
   void OnDestroyCommandBuffer(int32 route_id);
   void OnCreateJpegDecoder(int32 route_id, IPC::Message* reply_msg);
 
-  // Decrement the count of unhandled IPC messages and defer preemption.
-  void MessageProcessed();
+  void PushUnfinishedMessage(uint32_t order_number,
+                             const IPC::Message& message);
+  void ScheduleHandleMessage();
+  void ScheduleHandleMessageLocked();
+
+  // Update processed order number and defer preemption.
+  void MessageProcessed(uint32_t order_number);
 
   // The lifetime of objects of this class is managed by a GpuChannelManager.
   // The GpuChannelManager destroy all the GpuChannels that they own when they
   // are destroyed. So a raw pointer is safe.
   GpuChannelManager* gpu_channel_manager_;
 
   scoped_ptr<IPC::SyncChannel> channel_;
 
   // Uniquely identifies the channel within this GPU process.
   std::string channel_id_;
 
   // Used to implement message routing functionality to CommandBuffer objects
   MessageRouter router_;
 
-  uint64 messages_processed_;
-
   // Whether the processing of IPCs on this channel is stalled and we should
   // preempt other GpuChannels.
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
   // If non-NULL, all stubs on this channel should stop processing GL
   // commands (via their GpuScheduler) when preempted_flag_->IsSet()
   scoped_refptr<gpu::PreemptionFlag> preempted_flag_;
 
-  std::deque<IPC::Message*> deferred_messages_;
+  struct ChannelMessage {
+    uint32_t order_number;
+    base::TimeTicks time_received;
+    IPC::Message message;
+
+    // TODO(dyen): Temporary sync point data, remove once new sync point lands.
+    bool retire_sync_point;
+    uint32 sync_point_number;
+
+    ChannelMessage(uint32_t order_num, const IPC::Message& msg)
+      : order_number(order_num),
+        time_received(base::TimeTicks::Now()),
+        message(msg),
+        retire_sync_point(false),
+        sync_point_number(0) {}
+  };

[piman, 2015/08/31 23:15:04]

nit: move to before OnDestroy (within each visiblity section, order is types,
methods, fields per style guide)

[David Yen, 2015/09/01 02:01:52]

Done.

+  bool handle_messages_scheduled_;
+  std::deque<ChannelMessage*> channel_messages_;
+
+  // This lock protects both handle_messages_scheduled_ and channel_messages_.
+  base::Lock channel_messages_lock_;
+
 
   // The id of the client who is on the other side of the channel.
   int client_id_;
 
   // The tracing ID used for memory allocations associated with this client.
   uint64_t client_tracing_id_;
 
   // The task runners for the main thread and the io thread.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The share group that all contexts associated with a particular renderer
   // process use.
   scoped_refptr<gfx::GLShareGroup> share_group_;
 
   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
 
   scoped_refptr<gpu::gles2::SubscriptionRefSet> subscription_ref_set_;
 
   scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state_;
 
   scoped_ptr<GpuJpegDecodeAccelerator> jpeg_decoder_;
 
   gpu::gles2::DisallowedFeatures disallowed_features_;
   GpuWatchdog* watchdog_;
   bool software_;
-  bool handle_messages_scheduled_;
-  IPC::Message* currently_processing_message_;
+  ChannelMessage* currently_processing_message_;
+
+  // Current IPC order number being processed.
+  uint32_t current_order_num_;
+
+  // Last finished IPC order number.
+  uint32_t processed_order_num_;
+
+  // Highest IPC order number seen, set when queued on the IO thread.
+  base::subtle::Atomic32 unprocessed_order_num_;

[piman, 2015/08/31 23:15:04]

As far as I can tell, this is only used in a DCHECK, so I'm not sure it's useful
to optimize it as an Atomic32. Instead you can easily get it by going over the
messages in the queue (if you take the lock, which is fine to do in a DCHECK)

[David Yen, 2015/09/01 02:01:52]

This is going to be used later in the actual sync point wait implementation. It
is always written to on the IO thread and read from from main thread from the
GetUnprocessedOrderNum() function.

 
   size_t num_stubs_descheduled_;
-
   bool allow_future_sync_points_;
 
   // Member variables should appear before the WeakPtrFactory, to ensure
   // that any WeakPtrs to Controller are invalidated before its members
   // variable's destructors are executed, rendering them invalid.
   base::WeakPtrFactory<GpuChannel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannel);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_