gpu: Add SequenceId for identifying sync point sequences.

gpu/ipc/service/gpu_command_buffer_stub.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 "gpu/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 99 matching lines @@
             base::Bind(&GpuCommandBufferMemoryTracker::LogMemoryStatsPressure,
                        base::Unretained(this)))) {
     // Set up |memory_stats_timer_| to call LogMemoryPeriodic periodically
     // via the provided |task_runner|.
     memory_stats_timer_.SetTaskRunner(std::move(task_runner));
     memory_stats_timer_.Start(
         FROM_HERE, base::TimeDelta::FromSeconds(30), this,
         &GpuCommandBufferMemoryTracker::LogMemoryStatsPeriodic);
   }
 
-  void TrackMemoryAllocatedChange(
-      size_t old_size, size_t new_size) override {
-    tracking_group_->TrackMemoryAllocatedChange(
-        old_size, new_size);
+  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) override {
+    tracking_group_->TrackMemoryAllocatedChange(old_size, new_size);
   }
 
   bool EnsureGPUMemoryAvailable(size_t size_needed) override {
     return tracking_group_->EnsureGPUMemoryAvailable(size_needed);
   }
 
   uint64_t ClientTracingId() const override { return client_tracing_id_; }
   int ClientId() const override { return client_id_; }
   uint64_t ShareGroupTracingGUID() const override {
     return share_group_tracing_guid_;
@@ skipping 72 matching lines @@
 };
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 DevToolsChannelData::CreateForChannel(GpuChannel* channel) {
   std::unique_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   return base::WrapUnique(new DevToolsChannelData(res.release()));
 }
 
-CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
-  return CommandBufferId::FromUnsafeValue(
-      (static_cast<uint64_t>(channel_id) << 32) | route_id);
-}
-
 }  // namespace
 
 std::unique_ptr<GpuCommandBufferStub> GpuCommandBufferStub::Create(
     GpuChannel* channel,
     GpuCommandBufferStub* share_command_buffer_stub,
     const GPUCreateCommandBufferConfig& init_params,
+    CommandBufferId command_buffer_id,
+    SequenceId sequence_id,
+    int32_t stream_id,
     int32_t route_id,
     std::unique_ptr<base::SharedMemory> shared_state_shm) {
   std::unique_ptr<GpuCommandBufferStub> stub(
-      new GpuCommandBufferStub(channel, init_params, route_id));
+      new GpuCommandBufferStub(channel, init_params, command_buffer_id,
+                               sequence_id, stream_id, route_id));
   if (!stub->Initialize(share_command_buffer_stub, init_params,
                         std::move(shared_state_shm)))
     return nullptr;
   return stub;
 }
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     const GPUCreateCommandBufferConfig& init_params,
+    CommandBufferId command_buffer_id,
+    SequenceId sequence_id,
+    int32_t stream_id,
     int32_t route_id)
     : channel_(channel),
       initialized_(false),
       surface_handle_(init_params.surface_handle),
       use_virtualized_gl_context_(false),
-      command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
-      stream_id_(init_params.stream_id),
+      command_buffer_id_(command_buffer_id),
+      sequence_id_(sequence_id),
+      stream_id_(stream_id),
       route_id_(route_id),
       last_flush_count_(0),
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
       active_url_(init_params.active_url),
       active_url_hash_(base::Hash(active_url_.possibly_invalid_spec())) {}
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 }
 
 GpuMemoryManager* GpuCommandBufferStub::GetMemoryManager() const {
-    return channel()->gpu_channel_manager()->gpu_memory_manager();
+  return channel()->gpu_channel_manager()->gpu_memory_manager();
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
-  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
-               "GPUTask",
-               "data",
-               DevToolsChannelData::CreateForChannel(channel()));
+  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "GPUTask",
+               "data", DevToolsChannelData::CreateForChannel(channel()));
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
 
   bool have_context = false;
   // Ensure the appropriate GL context is current before handling any IPC
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current (not necessary for
   // RetireSyncPoint or WaitSyncPoint).
   if (decoder_.get() &&
       message.type() != GpuCommandBufferMsg_SetGetBuffer::ID &&
       message.type() != GpuCommandBufferMsg_WaitForTokenInRange::ID &&
@@ skipping 19 matching lines @@
                         OnReturnFrontBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_WaitForTokenInRange,
                                     OnWaitForTokenInRange);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_WaitForGetOffsetInRange,
                                     OnWaitForGetOffsetInRange);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken,
-                        OnWaitSyncToken)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken,
-                        OnSignalSyncToken)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
-                        OnSignalQuery)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken, OnWaitSyncToken)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken, OnSignalSyncToken)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery, OnSignalQuery)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
   // Ensure that any delayed work that was created will be handled.
@@ skipping 85 matching lines @@
 
 void GpuCommandBufferStub::PerformWork() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::PerformWork");
 
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
   if (decoder_.get() && !MakeCurrent())
     return;
 
   if (executor_) {
     uint32_t current_unprocessed_num =
-        channel()->gpu_channel_manager()->GetUnprocessedOrderNum();
+        channel()->sync_point_manager()->GetUnprocessedOrderNum();
     // We're idle when no messages were processed or scheduled.
     bool is_idle = (previous_processed_num_ == current_unprocessed_num);
     if (!is_idle && !last_idle_time_.is_null()) {
       base::TimeDelta time_since_idle =
           base::TimeTicks::Now() - last_idle_time_;
       base::TimeDelta max_time_since_idle =
           base::TimeDelta::FromMilliseconds(kMaxTimeSinceIdleMs);
 
       // Force idle when it's been too long since last time we were idle.
       if (time_since_idle > max_time_since_idle)
@@ skipping 10 matching lines @@
   }
 
   ScheduleDelayedWork(
       base::TimeDelta::FromMilliseconds(kHandleMoreWorkPeriodBusyMs));
 }
 
 bool GpuCommandBufferStub::HasUnprocessedCommands() {
   if (command_buffer_) {
     CommandBuffer::State state = command_buffer_->GetLastState();
     return command_buffer_->GetPutOffset() != state.get_offset &&
-        !error::IsError(state.error);
+           !error::IsError(state.error);
   }
   return false;
 }
 
 void GpuCommandBufferStub::ScheduleDelayedWork(base::TimeDelta delay) {
   bool has_more_work = executor_.get() && (executor_->HasPendingQueries() ||
                                            executor_->HasMoreIdleWork() ||
                                            executor_->HasPollingWork());
   if (!has_more_work) {
     last_idle_time_ = base::TimeTicks();
     return;
   }
 
   base::TimeTicks current_time = base::TimeTicks::Now();
   // |process_delayed_work_time_| is set if processing of delayed work is
   // already scheduled. Just update the time if already scheduled.
   if (!process_delayed_work_time_.is_null()) {
     process_delayed_work_time_ = current_time + delay;
     return;
   }
 
   // Idle when no messages are processed between now and when
   // PollWork is called.
   previous_processed_num_ =
-      channel()->gpu_channel_manager()->GetProcessedOrderNum();
+      channel()->sync_point_manager()->GetProcessedOrderNum();
   if (last_idle_time_.is_null())
     last_idle_time_ = current_time;
 
   // IsScheduled() returns true after passing all unschedule fences
   // and this is when we can start performing idle work. Idle work
   // is done synchronously so we can set delay to 0 and instead poll
   // for more work at the rate idle work is performed. This also ensures
   // that idle work is done as efficiently as possible without any
   // unnecessary delays.
   if (executor_.get() && executor_->scheduled() &&
@@ skipping 26 matching lines @@
     Send(wait_for_get_offset_->reply.release());
     wait_for_get_offset_.reset();
   }
 
   if (initialized_) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     // If we are currently shutting down the GPU process to help with recovery
     // (exit_on_context_lost workaround), then don't tell the browser about
     // offscreen context destruction here since it's not client-invoked, and
     // might bypass the 3D API blocking logic.
-    if ((surface_handle_ == gpu::kNullSurfaceHandle) && !active_url_.is_empty()
-        && !gpu_channel_manager->is_exiting_for_lost_context()) {
+    if ((surface_handle_ == gpu::kNullSurfaceHandle) &&
+        !active_url_.is_empty() &&
+        !gpu_channel_manager->is_exiting_for_lost_context()) {
       gpu_channel_manager->delegate()->DidDestroyOffscreenContext(active_url_);
     }
   }
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   executor_.reset();
 
-  sync_point_client_.reset();
+  if (sync_point_client_state_) {
+    sync_point_client_state_->Destroy();
+    sync_point_client_state_ = nullptr;
+  }
 
   bool have_context = false;
   if (decoder_ && decoder_->GetGLContext()) {
     // Try to make the context current regardless of whether it was lost, so we
     // don't leak resources.
     have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
   }
   for (auto& observer : destruction_observers_)
     observer.OnWillDestroyStub();
 
@@ skipping 88 matching lines @@
   }
 
   // We can only use virtualized contexts for onscreen command buffers if their
   // config is compatible with the offscreen ones - otherwise MakeCurrent fails.
   // Example use case is a client requesting an onscreen RGBA8888 buffer for
   // fullscreen video on a low-spec device with RGB565 default format.
   if (!surface_format.IsCompatible(default_surface->GetFormat()) && !offscreen)
     use_virtualized_gl_context_ = false;
 #endif
 
-  command_buffer_.reset(new CommandBufferService(
-      context_group_->transfer_buffer_manager()));
+  command_buffer_.reset(
+      new CommandBufferService(context_group_->transfer_buffer_manager()));
 
   decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                       decoder_.get()));
-  sync_point_client_ = base::MakeUnique<SyncPointClient>(
-      channel_->sync_point_manager(),
-      channel_->GetSyncPointOrderData(stream_id_),
-      CommandBufferNamespace::GPU_IO, command_buffer_id_);
+
+  sync_point_client_state_ =
+      channel_->sync_point_manager()->CreateSyncPointClientState(
+          CommandBufferNamespace::GPU_IO, command_buffer_id_, sequence_id_);
 
   executor_->SetPreemptByFlag(channel_->preempted_flag());
 
   decoder_->set_engine(executor_.get());
 
   if (offscreen) {
     if (init_params.attribs.depth_size > 0) {
       surface_format.SetDepthBits(init_params.attribs.depth_size);
     }
     if (init_params.attribs.samples > 0) {
@@ skipping 89 matching lines @@
     DLOG(ERROR) << "Failed to create context.";
     return false;
   }
 
   if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
     return false;
   }
 
   if (!context->GetGLStateRestorer()) {
-    context->SetGLStateRestorer(
-        new GLStateRestorerImpl(decoder_->AsWeakPtr()));
+    context->SetGLStateRestorer(new GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
   if (!context_group_->has_program_cache() &&
       !context_group_->feature_info()->workarounds().disable_program_cache) {
     context_group_->set_program_cache(manager->program_cache());
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
   if (!decoder_->Initialize(surface_, context, offscreen,
                             gpu::gles2::DisallowedFeatures(),
                             init_params.attribs)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
     return false;
   }
 
   if (manager->gpu_preferences().enable_gpu_service_logging) {
     decoder_->set_log_commands(true);
   }
 
-  decoder_->GetLogger()->SetMsgCallback(
-      base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
-                 base::Unretained(this)));
-  decoder_->SetShaderCacheCallback(
-      base::Bind(&GpuCommandBufferStub::SendCachedShader,
-                 base::Unretained(this)));
+  decoder_->GetLogger()->SetMsgCallback(base::Bind(
+      &GpuCommandBufferStub::SendConsoleMessage, base::Unretained(this)));
+  decoder_->SetShaderCacheCallback(base::Bind(
+      &GpuCommandBufferStub::SendCachedShader, base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &GpuCommandBufferStub::OnFenceSyncRelease, base::Unretained(this)));
   decoder_->SetWaitSyncTokenCallback(base::Bind(
       &GpuCommandBufferStub::OnWaitSyncToken, base::Unretained(this)));
   decoder_->SetDescheduleUntilFinishedCallback(
       base::Bind(&GpuCommandBufferStub::OnDescheduleUntilFinished,
                  base::Unretained(this)));
   decoder_->SetRescheduleAfterFinishedCallback(
       base::Bind(&GpuCommandBufferStub::OnRescheduleAfterFinished,
                  base::Unretained(this)));
@@ skipping 104 matching lines @@
   }
   wait_for_get_offset_ =
       base::MakeUnique<WaitForCommandState>(start, end, reply_message);
   CheckCompleteWaits();
 }
 
 void GpuCommandBufferStub::CheckCompleteWaits() {
   if (wait_for_token_ || wait_for_get_offset_) {
     CommandBuffer::State state = command_buffer_->GetLastState();
     if (wait_for_token_ &&
-        (CommandBuffer::InRange(
-             wait_for_token_->start, wait_for_token_->end, state.token) ||
+        (CommandBuffer::InRange(wait_for_token_->start, wait_for_token_->end,
+                                state.token) ||
          state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForTokenInRange::WriteReplyParams(
           wait_for_token_->reply.get(), state);
       Send(wait_for_token_->reply.release());
       wait_for_token_.reset();
     }
     if (wait_for_get_offset_ &&
         (CommandBuffer::InRange(wait_for_get_offset_->start,
-                                     wait_for_get_offset_->end,
-                                     state.get_offset) ||
+                                wait_for_get_offset_->end, state.get_offset) ||
          state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForGetOffsetInRange::WriteReplyParams(
           wait_for_get_offset_->reply.get(), state);
       Send(wait_for_get_offset_->reply.release());
       wait_for_get_offset_.reset();
     }
   }
 }
 
@@ skipping 58 matching lines @@
 
   if (command_buffer_)
     command_buffer_->DestroyTransferBuffer(id);
 }
 
 void GpuCommandBufferStub::OnCommandProcessed() {
   DCHECK(channel_->watchdog());
   channel_->watchdog()->CheckArmed();
 }
 
-void GpuCommandBufferStub::ReportState() { command_buffer_->UpdateState(); }
+void GpuCommandBufferStub::ReportState() {
+  command_buffer_->UpdateState();
+}
 
 void GpuCommandBufferStub::PutChanged() {
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
   executor_->PutChanged();
 }
 
 void GpuCommandBufferStub::OnSignalSyncToken(const SyncToken& sync_token,
                                              uint32_t id) {
-  if (!sync_point_client_->WaitNonThreadSafe(
+  if (!sync_point_client_state_->WaitNonThreadSafe(
           sync_token, channel_->task_runner(),
           base::Bind(&GpuCommandBufferStub::OnSignalAck, this->AsWeakPtr(),
                      id))) {
     OnSignalAck(id);
   }
 }
 
 void GpuCommandBufferStub::OnSignalAck(uint32_t id) {
   Send(new GpuCommandBufferMsg_SignalAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnSignalQuery(uint32_t query_id, uint32_t id) {
   if (decoder_) {
     gles2::QueryManager* query_manager = decoder_->GetQueryManager();
     if (query_manager) {
-      gles2::QueryManager::Query* query =
-          query_manager->GetQuery(query_id);
+      gles2::QueryManager::Query* query = query_manager->GetQuery(query_id);
       if (query) {
-        query->AddCallback(
-          base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                     this->AsWeakPtr(),
-                     id));
+        query->AddCallback(base::Bind(&GpuCommandBufferStub::OnSignalAck,
+                                      this->AsWeakPtr(), id));
         return;
       }
     }
   }
   // Something went wrong, run callback immediately.
   OnSignalAck(id);
 }
 
 void GpuCommandBufferStub::OnFenceSyncRelease(uint64_t release) {
   SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0, command_buffer_id_,
                        release);
   gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PushTextureUpdates(sync_token);
 
   command_buffer_->SetReleaseCount(release);
-  sync_point_client_->ReleaseFenceSync(release);
+  sync_point_client_state_->ReleaseFenceSync(release);
 }
 
 void GpuCommandBufferStub::OnDescheduleUntilFinished() {
   DCHECK(executor_->scheduled());
   DCHECK(executor_->HasPollingWork());
 
   executor_->SetScheduled(false);
-  channel_->OnStreamRescheduled(stream_id_, false);
+  channel_->OnCommandBufferDescheduled(this);
 }
 
 void GpuCommandBufferStub::OnRescheduleAfterFinished() {
   DCHECK(!executor_->scheduled());
 
   executor_->SetScheduled(true);
-  channel_->OnStreamRescheduled(stream_id_, true);
+  channel_->OnCommandBufferScheduled(this);
 }
 
 bool GpuCommandBufferStub::OnWaitSyncToken(const SyncToken& sync_token) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(executor_->scheduled());
   TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncToken", this, "GpuCommandBufferStub",
                            this);
 
-  waiting_for_sync_point_ = sync_point_client_->WaitNonThreadSafe(
+  waiting_for_sync_point_ = sync_point_client_state_->WaitNonThreadSafe(
       sync_token, channel_->task_runner(),
       base::Bind(&GpuCommandBufferStub::OnWaitSyncTokenCompleted, AsWeakPtr(),
                  sync_token));
 
   if (waiting_for_sync_point_) {
     executor_->SetScheduled(false);
-    channel_->OnStreamRescheduled(stream_id_, false);
+    channel_->OnCommandBufferDescheduled(this);
     return true;
   }
 
   gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PullTextureUpdates(sync_token);
   return false;
 }
 
 void GpuCommandBufferStub::OnWaitSyncTokenCompleted(
     const SyncToken& sync_token) {
   DCHECK(waiting_for_sync_point_);
   TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncTokenCompleted", this,
                          "GpuCommandBufferStub", this);
   // Don't call PullTextureUpdates here because we can't MakeCurrent if we're
   // executing commands on another context. The WaitSyncToken command will run
   // again and call PullTextureUpdates once this command buffer gets scheduled.
   waiting_for_sync_point_ = false;
   executor_->SetScheduled(true);
-  channel_->OnStreamRescheduled(stream_id_, true);
+  channel_->OnCommandBufferScheduled(this);
 }
 
 void GpuCommandBufferStub::OnCreateImage(
     const GpuCommandBufferMsg_CreateImage_Params& params) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateImage");
   const int32_t id = params.id;
   const gfx::GpuMemoryBufferHandle& handle = params.gpu_memory_buffer;
   const gfx::Size& size = params.size;
   const gfx::BufferFormat& format = params.format;
   const uint32_t internalformat = params.internal_format;
@@ skipping 26 matching lines @@
     return;
   }
 
   scoped_refptr<gl::GLImage> image = channel()->CreateImageForGpuMemoryBuffer(
       handle, size, format, internalformat, surface_handle_);
   if (!image.get())
     return;
 
   image_manager->AddImage(image.get(), id);
   if (image_release_count)
-    sync_point_client_->ReleaseFenceSync(image_release_count);
+    sync_point_client_state_->ReleaseFenceSync(image_release_count);
 }
 
 void GpuCommandBufferStub::OnDestroyImage(int32_t id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyImage");
 
   if (!decoder_)
     return;
 
   gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
@@ skipping 68 matching lines @@
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
 }  // namespace gpu